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};33use scale_info::TypeInfo;34use 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 MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 71 pub enum Error for Module<T: Config> {72 73 TotalCollectionsLimitExceeded,74 75 CollectionDecimalPointLimitExceeded,76 77 CollectionNameLimitExceeded,78 79 CollectionDescriptionLimitExceeded,80 81 CollectionTokenPrefixLimitExceeded,82 83 CollectionNotFound,84 85 TokenNotFound,86 87 AdminNotFound,88 89 NumOverflow,90 91 AlreadyAdmin,92 93 NoPermission,94 95 ConfirmUnsetSponsorFail,96 97 PublicMintingNotAllowed,98 99 MustBeTokenOwner,100 101 TokenValueTooLow,102 103 NftSizeLimitExceeded,104 105 ApproveNotFound,106 107 TokenValueNotEnough,108 109 ApproveRequired,110 111 AddresNotInWhiteList,112 113 CollectionAdminsLimitExceeded,114 115 AddressOwnershipLimitExceeded,116 117 EmptyArgument,118 119 TokenConstDataLimitExceeded,120 121 TokenVariableDataLimitExceeded,122 123 NotNftDataUsedToMintNftCollectionToken,124 125 NotFungibleDataUsedToMintFungibleCollectionToken,126 127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 129 UnexpectedCollectionType,130 131 CantStoreMetadataInFungibleTokens,132 133 CollectionTokenLimitExceeded,134 135 AccountTokenLimitExceeded,136 137 CollectionLimitBoundsExceeded,138 139 OwnerPermissionsCantBeReverted,140 141 SchemaDataLimitExceeded,142 143 WrongRefungiblePieces,144 145 BadCreateRefungibleCall,146 147 OutOfGas,148 149 MetadataUpdateDenied,150 151 MetadataFlagFrozen,152 153 TransferNotAllowed,154 155 AddressIsZero,156 }157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161 pub id: CollectionId,162 collection: Collection<T>,163 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167 <CollectionById<T>>::get(id).map(|collection| Self {168 id,169 collection,170 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171 eth::collection_id_to_address(id),172 gas_limit,173 ),174 })175 }176 pub fn get(id: CollectionId) -> Option<Self> {177 Self::get_with_gas_limit(id, u64::MAX)178 }179 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180 self.recorder.log_sub(log)181 }182 #[allow(dead_code)]183 fn consume_gas(&self, gas: u64) -> DispatchResult {184 self.recorder.consume_gas_sub(gas)185 }186 fn consume_sload(&self) -> DispatchResult {187 self.recorder.consume_sload_sub()188 }189 fn consume_sstore(&self) -> DispatchResult {190 self.recorder.consume_sstore_sub()191 }192 pub fn submit_logs(self) -> DispatchResult {193 self.recorder.submit_logs()194 }195 pub fn save(self) -> DispatchResult {196 self.recorder.submit_logs()?;197 <CollectionById<T>>::insert(self.id, self.collection);198 Ok(())199 }200}201impl<T: Config> Deref for CollectionHandle<T> {202 type Target = Collection<T>;203204 fn deref(&self) -> &Self::Target {205 &self.collection206 }207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210 fn deref_mut(&mut self) -> &mut Self::Target {211 &mut self.collection212 }213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized + TypeInfo {216 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218 219 type WeightInfo: WeightInfo;220221 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224 type CrossAccountId: CrossAccountId<Self::AccountId>;225 type Currency: Currency<Self::AccountId>;226 type CollectionCreationPrice: Get<227 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228 >;229 type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235 fn transfer() -> Weight {236 Self::transfer_nft()237 .max(Self::transfer_fungible())238 .max(Self::transfer_refungible())239 }240 fn transfer_from() -> Weight {241 Self::transfer_from_nft()242 .max(Self::transfer_from_fungible())243 .max(Self::transfer_from_refungible())244 }245 fn approve() -> Weight {246 247 Self::approve_nft()248 }249 fn set_variable_meta_data(data: u32) -> Weight {250 251 Self::set_variable_meta_data_nft(data)252 }253 fn create_item(data: u32) -> Weight {254 Self::create_item_nft(data)255 .max(Self::create_item_fungible())256 .max(Self::create_item_refungible(data))257 }258 fn create_multiple_items(amount: u32) -> Weight {259 Self::create_multiple_items_nft(amount)260 .max(Self::create_multiple_items_fungible(amount))261 .max(Self::create_multiple_items_refungible(amount))262 }263 fn burn_item() -> Weight {264 265 Self::burn_item_nft()266 }267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270271272273274275276277278279280281282283284285286287288289290291292decl_storage! {293 trait Store for Module<T: Config> as Nft {294295 296 297 CreatedCollectionCount: u32;298 299 ChainVersion: u64;300 301 302 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303 304305 306 307 308 DestroyedCollectionCount: u32;309 310311 312 313 314 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315 316 317 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318 319 320 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321 322323 324 325 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327 328 329 330 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332 333 334 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335 336 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337 338 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339 340341 342 343 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344 345346 347 348 349 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350 351 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352 353 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354 355 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356 357358 359 360 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361 }362 add_extra_genesis {363 build(|config: &GenesisConfig<T>| {364 365 for (_num, _c) in &config.collection_id {366 <Module<T>>::init_collection(_c);367 }368369 for (_num, _c, _i) in &config.nft_item_id {370 <Module<T>>::init_nft_token(*_c, _i);371 }372373 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375 }376377 for (_num, _c, _i) in &config.refungible_item_id {378 <Module<T>>::init_refungible_token(*_c, _i);379 }380 })381 }382}383384decl_event!(385 pub enum Event<T>386 where387 AccountId = <T as frame_system::Config>::AccountId,388 CrossAccountId = <T as Config>::CrossAccountId,389 {390 391 392 393 394 395 396 397 398 399 CollectionCreated(CollectionId, u8, AccountId),400401 402 403 404 405 406 407 408 409 410 ItemCreated(CollectionId, TokenId, CrossAccountId),411412 413 414 415 416 417 418 419 ItemDestroyed(CollectionId, TokenId),420421 422 423 424 425 426 427 428 429 430 431 432 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434 435 436 437 438 439 440 441 442 443 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444 }445);446447decl_module! {448 pub struct Module<T: Config> for enum Call449 where450 origin: T::Origin451 {452 fn deposit_event() = default;453 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454 type Error = Error<T>;455456 fn on_initialize(_now: T::BlockNumber) -> Weight {457 0458 }459460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 #[weight = <SelfWeightOf<T>>::create_collection()]477 #[transactional]478 pub fn create_collection(origin,479 collection_name: Vec<u16>,480 collection_description: Vec<u16>,481 token_prefix: Vec<u8>,482 mode: CollectionMode) -> DispatchResult {483484 485 let who = ensure_signed(origin)?;486487 488 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490 &T::TreasuryAccountId::get(),491 T::CollectionCreationPrice::get(),492 ));493 <T as Config>::Currency::settle(494 &who,495 imbalance,496 WithdrawReasons::TRANSFER,497 ExistenceRequirement::KeepAlive,498 ).map_err(|_| Error::<T>::NoPermission)?;499500 let decimal_points = match mode {501 CollectionMode::Fungible(points) => points,502 _ => 0503 };504505 let created_count = CreatedCollectionCount::get();506 let destroyed_count = DestroyedCollectionCount::get();507508 509 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511 512 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517 518 let next_id = created_count519 .checked_add(1)520 .ok_or(Error::<T>::NumOverflow)?;521522 CreatedCollectionCount::put(next_id);523524 let limits = CollectionLimits {525 sponsored_data_size: CUSTOM_DATA_LIMIT,526 ..Default::default()527 };528529 530 let new_collection = Collection {531 owner: who.clone(),532 name: collection_name,533 mode: mode.clone(),534 mint_mode: false,535 access: AccessMode::Normal,536 description: collection_description,537 decimal_points,538 token_prefix,539 offchain_schema: Vec::new(),540 schema_version: SchemaVersion::ImageURL,541 sponsorship: SponsorshipState::Disabled,542 variable_on_chain_schema: Vec::new(),543 const_on_chain_schema: Vec::new(),544 limits,545 meta_update_permission: MetaUpdatePermission::default(),546 transfers_enabled: true,547 };548549 550 <CollectionById<T>>::insert(next_id, new_collection);551552 553 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555 Ok(())556 }557558 559 560 561 562 563 564 565 566 567 #[weight = <SelfWeightOf<T>>::destroy_collection()]568 #[transactional]569 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571 let sender = ensure_signed(origin)?;572 let collection = Self::get_collection(collection_id)?;573 Self::check_owner_permissions(&collection, &sender)?;574 if !collection.limits.owner_can_destroy {575 fail!(Error::<T>::NoPermission);576 }577578 <AddressTokens<T>>::remove_prefix(collection_id, None);579 <Allowances<T>>::remove_prefix(collection_id, None);580 <Balance<T>>::remove_prefix(collection_id, None);581 <ItemListIndex>::remove(collection_id);582 <AdminList<T>>::remove(collection_id);583 <CollectionById<T>>::remove(collection_id);584 <WhiteList<T>>::remove_prefix(collection_id, None);585586 <NftItemList<T>>::remove_prefix(collection_id, None);587 <FungibleItemList<T>>::remove_prefix(collection_id, None);588 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590 <NftTransferBasket<T>>::remove_prefix(collection_id, None);591 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596 DestroyedCollectionCount::put(DestroyedCollectionCount::get()597 .checked_add(1)598 .ok_or(Error::<T>::NumOverflow)?);599600 Ok(())601 }602603 604 605 606 607 608 609 610 611 612 613 614 615 #[weight = <SelfWeightOf<T>>::add_to_white_list()]616 #[transactional]617 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620 let collection = Self::get_collection(collection_id)?;621622 Self::toggle_white_list_internal(623 &sender,624 &collection,625 &address,626 true,627 )?;628629 Ok(())630 }631632 633 634 635 636 637 638 639 640 641 642 643 644 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]645 #[transactional]646 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649 let collection = Self::get_collection(collection_id)?;650651 Self::toggle_white_list_internal(652 &sender,653 &collection,654 &address,655 false,656 )?;657658 Ok(())659 }660661 662 663 664 665 666 667 668 669 670 671 672 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]673 #[transactional]674 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675 {676 let sender = ensure_signed(origin)?;677678 let mut target_collection = Self::get_collection(collection_id)?;679 Self::check_owner_permissions(&target_collection, &sender)?;680 target_collection.access = mode;681 target_collection.save()682 }683684 685 686 687 688 689 690 691 692 693 694 695 696 697 #[weight = <SelfWeightOf<T>>::set_mint_permission()]698 #[transactional]699 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700 {701 let sender = ensure_signed(origin)?;702703 let mut target_collection = Self::get_collection(collection_id)?;704 Self::check_owner_permissions(&target_collection, &sender)?;705 target_collection.mint_mode = mint_permission;706 target_collection.save()707 }708709 710 711 712 713 714 715 716 717 718 719 720 #[weight = <SelfWeightOf<T>>::change_collection_owner()]721 #[transactional]722 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724 let sender = ensure_signed(origin)?;725 let mut target_collection = Self::get_collection(collection_id)?;726 Self::check_owner_permissions(&target_collection, &sender)?;727 target_collection.owner = new_owner;728 target_collection.save()729 }730731 732 733 734 735 736 737 738 739 740 741 742 743 744 #[weight = <SelfWeightOf<T>>::add_collection_admin()]745 #[transactional]746 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748 let collection = Self::get_collection(collection_id)?;749 Self::check_owner_or_admin_permissions(&collection, &sender)?;750 let mut admin_arr = <AdminList<T>>::get(collection_id);751752 match admin_arr.binary_search(&new_admin_id) {753 Ok(_) => {},754 Err(idx) => {755 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756 admin_arr.insert(idx, new_admin_id);757 <AdminList<T>>::insert(collection_id, admin_arr);758 }759 }760 Ok(())761 }762763 764 765 766 767 768 769 770 771 772 773 774 775 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]776 #[transactional]777 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779 let collection = Self::get_collection(collection_id)?;780 Self::check_owner_or_admin_permissions(&collection, &sender)?;781 let mut admin_arr = <AdminList<T>>::get(collection_id);782783 if let Ok(idx) = admin_arr.binary_search(&account_id) {784 admin_arr.remove(idx);785 <AdminList<T>>::insert(collection_id, admin_arr);786 }787 Ok(())788 }789790 791 792 793 794 795 796 797 798 799 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800 #[transactional]801 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802 let sender = ensure_signed(origin)?;803 let mut target_collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&target_collection, &sender)?;805806 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807 target_collection.save()808 }809810 811 812 813 814 815 816 817 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818 #[transactional]819 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820 let sender = ensure_signed(origin)?;821822 let mut target_collection = Self::get_collection(collection_id)?;823 ensure!(824 target_collection.sponsorship.pending_sponsor() == Some(&sender),825 Error::<T>::ConfirmUnsetSponsorFail826 );827828 target_collection.sponsorship = SponsorshipState::Confirmed(sender);829 target_collection.save()830 }831832 833 834 835 836 837 838 839 840 841 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842 #[transactional]843 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844 let sender = ensure_signed(origin)?;845846 let mut target_collection = Self::get_collection(collection_id)?;847 Self::check_owner_permissions(&target_collection, &sender)?;848849 target_collection.sponsorship = SponsorshipState::Disabled;850 target_collection.save()851 }852853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876877 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878 #[transactional]879 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881 let collection = Self::get_collection(collection_id)?;882883 Self::create_item_internal(&sender, &collection, &owner, data)?;884885 collection.submit_logs()886 }887888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907 #[transactional]908 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912 let collection = Self::get_collection(collection_id)?;913914 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916 collection.submit_logs()917 }918919 920921 922 923 924 925 926 927 928 929 930 931 932 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933 #[transactional]934 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936 let sender = ensure_signed(origin)?;937 let mut target_collection = Self::get_collection(collection_id)?;938939 Self::check_owner_permissions(&target_collection, &sender)?;940941 target_collection.transfers_enabled = value;942 target_collection.save()943 }944945 946 947 948 949 950 951 952 953 954 955 956 957 #[weight = <T as Config>::WeightInfo::burn_item()]958 #[transactional]959 pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961 let sender = ensure_signed(origin)?;962 let mut target_collection = Self::get_collection(collection_id)?;963964 ensure!(965 target_collection.meta_update_permission != MetaUpdatePermission::None,966 Error::<T>::MetadataFlagFrozen967 );968 Self::check_owner_permissions(&target_collection, &sender)?;969970 target_collection.meta_update_permission = value;971972 target_collection.save()973 }974975 976 977 978 979 980 981 982 983 984 985 986 987 988 #[weight = <SelfWeightOf<T>>::burn_item()]989 #[transactional]990 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {991992 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993 let target_collection = Self::get_collection(collection_id)?;994995 Self::burn_item_internal(&sender, &target_collection, item_id, value, true)?;996997 target_collection.submit_logs()998 }9991000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 #[weight = <SelfWeightOf<T>>::burn_item()]1017 #[transactional]1018 pub fn burn_from(origin, collection_id: CollectionId, from: T::CrossAccountId, item_id: TokenId, value: u128) -> DispatchResult {10191020 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1021 let target_collection = Self::get_collection(collection_id)?;10221023 Self::burn_from_internal(&sender, &target_collection, &from, item_id, value)?;10241025 target_collection.submit_logs()1026 }10271028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 #[weight = <SelfWeightOf<T>>::transfer()]1052 #[transactional]1053 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1054 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1055 let collection = Self::get_collection(collection_id)?;10561057 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10581059 collection.submit_logs()1060 }10611062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 #[weight = <SelfWeightOf<T>>::approve()]1078 #[transactional]1079 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1080 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1081 let collection = Self::get_collection(collection_id)?;10821083 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10841085 collection.submit_logs()1086 }10871088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 #[weight = <SelfWeightOf<T>>::transfer_from()]1108 #[transactional]1109 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1110 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1111 let collection = Self::get_collection(collection_id)?;11121113 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;11141115 collection.submit_logs()1116 }1117 1118 1119 1120 1121 11221123 11241125 11261127 1128 11291130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1143 #[transactional]1144 pub fn set_variable_meta_data (1145 origin,1146 collection_id: CollectionId,1147 item_id: TokenId,1148 data: Vec<u8>1149 ) -> DispatchResult {1150 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11511152 let collection = Self::get_collection(collection_id)?;1153 Self::meta_update_check(&sender, &collection, item_id)?;11541155 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11561157 Ok(())1158 }11591160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 #[weight = <SelfWeightOf<T>>::set_schema_version()]1175 #[transactional]1176 pub fn set_schema_version(1177 origin,1178 collection_id: CollectionId,1179 version: SchemaVersion1180 ) -> DispatchResult {1181 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1182 let mut target_collection = Self::get_collection(collection_id)?;1183 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1184 target_collection.schema_version = version;1185 target_collection.save()1186 }11871188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1201 #[transactional]1202 pub fn set_offchain_schema(1203 origin,1204 collection_id: CollectionId,1205 schema: Vec<u8>1206 ) -> DispatchResult {1207 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1208 let mut target_collection = Self::get_collection(collection_id)?;1209 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12101211 1212 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");12131214 target_collection.offchain_schema = schema;1215 target_collection.save()1216 }12171218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1231 #[transactional]1232 pub fn set_const_on_chain_schema (1233 origin,1234 collection_id: CollectionId,1235 schema: Vec<u8>1236 ) -> DispatchResult {1237 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1238 let mut target_collection = Self::get_collection(collection_id)?;1239 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12401241 1242 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12431244 target_collection.const_on_chain_schema = schema;1245 target_collection.save()1246 }12471248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1261 #[transactional]1262 pub fn set_variable_on_chain_schema (1263 origin,1264 collection_id: CollectionId,1265 schema: Vec<u8>1266 ) -> DispatchResult {1267 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1268 let mut target_collection = Self::get_collection(collection_id)?;1269 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12701271 1272 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12731274 target_collection.variable_on_chain_schema = schema;1275 target_collection.save()1276 }12771278 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1279 #[transactional]1280 pub fn set_collection_limits(1281 origin,1282 collection_id: u32,1283 new_limits: CollectionLimits<T::BlockNumber>,1284 ) -> DispatchResult {1285 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1286 let mut target_collection = Self::get_collection(collection_id)?;1287 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1288 let old_limits = &target_collection.limits;12891290 1291 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1292 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1293 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1294 Error::<T>::CollectionLimitBoundsExceeded);12951296 1297 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1298 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12991300 ensure!(1301 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1302 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1303 Error::<T>::OwnerPermissionsCantBeReverted,1304 );13051306 target_collection.limits = new_limits;13071308 target_collection.save()1309 }1310 }1311}13121313impl<T: Config> Module<T> {1314 pub fn create_item_internal(1315 sender: &T::CrossAccountId,1316 collection: &CollectionHandle<T>,1317 owner: &T::CrossAccountId,1318 data: CreateItemData,1319 ) -> DispatchResult {1320 ensure!(1321 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1322 Error::<T>::AddressIsZero1323 );13241325 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1326 Self::validate_create_item_args(collection, &data)?;1327 Self::create_item_no_validation(collection, owner, data)?;13281329 Ok(())1330 }13311332 pub fn transfer_internal(1333 sender: &T::CrossAccountId,1334 recipient: &T::CrossAccountId,1335 target_collection: &CollectionHandle<T>,1336 item_id: TokenId,1337 value: u128,1338 ) -> DispatchResult {1339 ensure!(1340 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1341 Error::<T>::AddressIsZero1342 );13431344 1345 Self::is_correct_transfer(target_collection, recipient)?;13461347 1348 ensure!(1349 Self::is_item_owner(sender, target_collection, item_id)?1350 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1351 Error::<T>::NoPermission1352 );13531354 if target_collection.access == AccessMode::WhiteList {1355 Self::check_white_list(target_collection, sender)?;1356 Self::check_white_list(target_collection, recipient)?;1357 }13581359 match target_collection.mode {1360 CollectionMode::NFT => Self::transfer_nft(1361 target_collection,1362 item_id,1363 sender.clone(),1364 recipient.clone(),1365 )?,1366 CollectionMode::Fungible(_) => {1367 Self::transfer_fungible(target_collection, value, sender, recipient)?1368 }1369 CollectionMode::ReFungible => Self::transfer_refungible(1370 target_collection,1371 item_id,1372 value,1373 sender.clone(),1374 recipient.clone(),1375 )?,1376 };13771378 Self::deposit_event(RawEvent::Transfer(1379 target_collection.id,1380 item_id,1381 sender.clone(),1382 recipient.clone(),1383 value,1384 ));13851386 Ok(())1387 }13881389 pub fn approve_internal(1390 sender: &T::CrossAccountId,1391 spender: &T::CrossAccountId,1392 collection: &CollectionHandle<T>,1393 item_id: TokenId,1394 amount: u128,1395 ) -> DispatchResult {1396 Self::token_exists(collection, item_id)?;13971398 1399 let bypasses_limits = collection.limits.owner_can_transfer1400 && Self::is_owner_or_admin_permissions(collection, sender)?;14011402 let allowance_limit = if bypasses_limits {1403 None1404 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1405 Some(amount)1406 } else {1407 fail!(Error::<T>::NoPermission);1408 };14091410 if collection.access == AccessMode::WhiteList {1411 Self::check_white_list(collection, sender)?;1412 Self::check_white_list(collection, spender)?;1413 }14141415 collection.consume_sload()?;1416 let allowance: u128 = amount1417 .checked_add(<Allowances<T>>::get(1418 collection.id,1419 (item_id, sender.as_sub(), spender.as_sub()),1420 ))1421 .ok_or(Error::<T>::NumOverflow)?;1422 if let Some(limit) = allowance_limit {1423 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1424 }1425 collection.consume_sstore()?;1426 <Allowances<T>>::insert(1427 collection.id,1428 (item_id, sender.as_sub(), spender.as_sub()),1429 allowance,1430 );14311432 if matches!(collection.mode, CollectionMode::NFT) {1433 1434 collection.log(ERC721Events::Approval {1435 owner: *sender.as_eth(),1436 approved: *spender.as_eth(),1437 token_id: item_id.into(),1438 })?;1439 }14401441 if matches!(collection.mode, CollectionMode::Fungible(_)) {1442 1443 collection.log(ERC20Events::Approval {1444 owner: *sender.as_eth(),1445 spender: *spender.as_eth(),1446 value: allowance.into(),1447 })?;1448 }14491450 Self::deposit_event(RawEvent::Approved(1451 collection.id,1452 item_id,1453 sender.clone(),1454 spender.clone(),1455 allowance,1456 ));1457 Ok(())1458 }14591460 pub fn transfer_from_internal(1461 sender: &T::CrossAccountId,1462 from: &T::CrossAccountId,1463 recipient: &T::CrossAccountId,1464 collection: &CollectionHandle<T>,1465 item_id: TokenId,1466 amount: u128,1467 ) -> DispatchResult {1468 if sender == from {1469 1470 return Self::transfer_internal(from, recipient, collection, item_id, amount);1471 }14721473 1474 collection.consume_sload()?;1475 let approval: u128 =1476 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14771478 1479 Self::is_correct_transfer(collection, recipient)?;14801481 1482 ensure!(1483 approval >= amount1484 || (collection.limits.owner_can_transfer1485 && Self::is_owner_or_admin_permissions(collection, sender)?),1486 Error::<T>::NoPermission1487 );14881489 if collection.access == AccessMode::WhiteList {1490 Self::check_white_list(collection, sender)?;1491 Self::check_white_list(collection, recipient)?;1492 }14931494 1495 let allowance = approval.saturating_sub(amount);1496 collection.consume_sstore()?;1497 if allowance > 0 {1498 <Allowances<T>>::insert(1499 collection.id,1500 (item_id, from.as_sub(), sender.as_sub()),1501 allowance,1502 );1503 } else {1504 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1505 }15061507 match collection.mode {1508 CollectionMode::NFT => {1509 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1510 }1511 CollectionMode::Fungible(_) => {1512 Self::transfer_fungible(collection, amount, from, recipient)?1513 }1514 CollectionMode::ReFungible => Self::transfer_refungible(1515 collection,1516 item_id,1517 amount,1518 from.clone(),1519 recipient.clone(),1520 )?,1521 };15221523 if matches!(collection.mode, CollectionMode::Fungible(_)) {1524 collection.log(ERC20Events::Approval {1525 owner: *from.as_eth(),1526 spender: *sender.as_eth(),1527 value: allowance.into(),1528 })?;1529 }15301531 Ok(())1532 }15331534 pub fn set_variable_meta_data_internal(1535 sender: &T::CrossAccountId,1536 collection: &CollectionHandle<T>,1537 item_id: TokenId,1538 data: Vec<u8>,1539 ) -> DispatchResult {1540 Self::token_exists(collection, item_id)?;15411542 ensure!(1543 CUSTOM_DATA_LIMIT >= data.len() as u32,1544 Error::<T>::TokenVariableDataLimitExceeded1545 );15461547 ensure!(1548 (Self::is_item_owner(sender, collection, item_id)?1549 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1550 || (Self::is_owner_or_admin_permissions(collection, sender)?1551 && collection.meta_update_permission == MetaUpdatePermission::Admin),1552 Error::<T>::NoPermission1553 );15541555 match collection.mode {1556 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1557 CollectionMode::ReFungible => {1558 Self::set_re_fungible_variable_data(collection, item_id, data)?1559 }1560 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1561 };15621563 Ok(())1564 }15651566 pub fn meta_update_check(1567 sender: &T::CrossAccountId,1568 collection: &CollectionHandle<T>,1569 item_id: TokenId,1570 ) -> DispatchResult {1571 match collection.meta_update_permission {1572 MetaUpdatePermission::ItemOwner => ensure!(1573 Self::is_item_owner(sender, collection, item_id)?,1574 Error::<T>::NoPermission1575 ),1576 MetaUpdatePermission::Admin => ensure!(1577 Self::is_owner_or_admin_permissions(collection, sender)?,1578 Error::<T>::NoPermission1579 ),1580 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1581 }15821583 Ok(())1584 }15851586 pub fn get_variable_metadata(1587 collection: &CollectionHandle<T>,1588 item_id: TokenId,1589 ) -> Result<Vec<u8>, DispatchError> {1590 Ok(match collection.mode {1591 CollectionMode::NFT => {1592 <NftItemList<T>>::get(collection.id, item_id)1593 .ok_or(Error::<T>::TokenNotFound)?1594 .variable_data1595 }1596 CollectionMode::ReFungible => {1597 <ReFungibleItemList<T>>::get(collection.id, item_id)1598 .ok_or(Error::<T>::TokenNotFound)?1599 .variable_data1600 }1601 _ => fail!(Error::<T>::UnexpectedCollectionType),1602 })1603 }16041605 pub fn create_multiple_items_internal(1606 sender: &T::CrossAccountId,1607 collection: &CollectionHandle<T>,1608 owner: &T::CrossAccountId,1609 items_data: Vec<CreateItemData>,1610 ) -> DispatchResult {1611 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;16121613 for data in &items_data {1614 Self::validate_create_item_args(collection, data)?;1615 }1616 for data in &items_data {1617 Self::create_item_no_validation(collection, owner, data.clone())?;1618 }16191620 Ok(())1621 }16221623 pub fn burn_item_internal(1624 owner: &T::CrossAccountId,1625 collection: &CollectionHandle<T>,1626 item_id: TokenId,1627 value: u128,1628 allow_escalation: bool,1629 ) -> DispatchResult {1630 ensure!(1631 Self::is_item_owner(owner, collection, item_id)?1632 || (allow_escalation1633 && collection.limits.owner_can_transfer1634 && Self::is_owner_or_admin_permissions(collection, owner)?),1635 Error::<T>::NoPermission1636 );16371638 if collection.access == AccessMode::WhiteList {1639 Self::check_white_list(collection, owner)?;1640 }16411642 match collection.mode {1643 CollectionMode::NFT => match value {1644 1 => Self::burn_nft_item(collection, item_id)?,1645 0 => (),1646 _ => fail!(<Error<T>>::TokenValueTooLow),1647 },1648 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,1649 CollectionMode::ReFungible => {1650 Self::burn_refungible_item(collection, item_id, owner, value)?1651 }1652 _ => (),1653 };16541655 Ok(())1656 }16571658 pub fn burn_from_internal(1659 sender: &T::CrossAccountId,1660 collection: &CollectionHandle<T>,1661 from: &T::CrossAccountId,1662 item_id: TokenId,1663 amount: u128,1664 ) -> DispatchResult {1665 if sender == from {1666 1667 return Self::burn_item_internal(from, collection, item_id, amount, true);1668 }16691670 1671 collection.consume_sload()?;1672 let approval: u128 =1673 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));16741675 1676 ensure!(1677 approval >= amount1678 || (collection.limits.owner_can_transfer1679 && Self::is_owner_or_admin_permissions(collection, sender)?),1680 Error::<T>::NoPermission1681 );16821683 if collection.access == AccessMode::WhiteList {1684 Self::check_white_list(collection, sender)?;1685 }16861687 1688 let allowance = approval.saturating_sub(amount);1689 collection.consume_sstore()?;1690 if allowance > 0 {1691 <Allowances<T>>::insert(1692 collection.id,1693 (item_id, from.as_sub(), sender.as_sub()),1694 allowance,1695 );1696 } else {1697 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1698 }16991700 1701 Self::burn_item_internal(from, collection, item_id, amount, false)?;17021703 if matches!(collection.mode, CollectionMode::Fungible(_)) {1704 collection.log(ERC20Events::Approval {1705 owner: *from.as_eth(),1706 spender: *sender.as_eth(),1707 value: allowance.into(),1708 })?;1709 }17101711 Ok(())1712 }17131714 pub fn toggle_white_list_internal(1715 sender: &T::CrossAccountId,1716 collection: &CollectionHandle<T>,1717 address: &T::CrossAccountId,1718 whitelisted: bool,1719 ) -> DispatchResult {1720 Self::check_owner_or_admin_permissions(collection, sender)?;17211722 if whitelisted {1723 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1724 } else {1725 <WhiteList<T>>::remove(collection.id, address.as_sub());1726 }17271728 Ok(())1729 }17301731 fn is_correct_transfer(1732 collection: &CollectionHandle<T>,1733 recipient: &T::CrossAccountId,1734 ) -> DispatchResult {1735 let collection_id = collection.id;17361737 1738 collection.consume_sload()?;1739 let account_items: u32 =1740 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;17411742 1743 1744 let limit = if collection.limits.account_token_ownership_limit == 01745 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1746 {1747 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1748 } else {1749 collection.limits.account_token_ownership_limit1750 };17511752 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);17531754 1755 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);17561757 Ok(())1758 }17591760 fn can_create_items_in_collection(1761 collection: &CollectionHandle<T>,1762 sender: &T::CrossAccountId,1763 owner: &T::CrossAccountId,1764 amount: u32,1765 ) -> DispatchResult {1766 let collection_id = collection.id;17671768 1769 let total_items: u32 = ItemListIndex::get(collection_id)1770 .checked_add(amount)1771 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1772 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1773 as u32)1774 .checked_add(amount)1775 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;17761777 1778 1779 let account_token_limit = if collection.limits.account_token_ownership_limit == 01780 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1781 {1782 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1783 } else {1784 collection.limits.account_token_ownership_limit1785 };17861787 ensure!(1788 collection.limits.token_limit >= total_items,1789 Error::<T>::CollectionTokenLimitExceeded1790 );1791 ensure!(1792 account_token_limit >= account_items,1793 Error::<T>::AccountTokenLimitExceeded1794 );17951796 if !Self::is_owner_or_admin_permissions(collection, sender)? {1797 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1798 Self::check_white_list(collection, owner)?;1799 Self::check_white_list(collection, sender)?;1800 }18011802 Ok(())1803 }18041805 fn validate_create_item_args(1806 target_collection: &CollectionHandle<T>,1807 data: &CreateItemData,1808 ) -> DispatchResult {1809 match target_collection.mode {1810 CollectionMode::NFT => {1811 if !matches!(data, CreateItemData::NFT(_)) {1812 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1813 }1814 }1815 CollectionMode::Fungible(_) => {1816 if !matches!(data, CreateItemData::Fungible(_)) {1817 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1818 }1819 }1820 CollectionMode::ReFungible => {1821 if let CreateItemData::ReFungible(data) = data {1822 1823 ensure!(1824 data.pieces <= MAX_REFUNGIBLE_PIECES,1825 Error::<T>::WrongRefungiblePieces1826 );1827 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1828 } else {1829 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1830 }1831 }1832 };18331834 Ok(())1835 }18361837 fn create_item_no_validation(1838 collection: &CollectionHandle<T>,1839 owner: &T::CrossAccountId,1840 data: CreateItemData,1841 ) -> DispatchResult {1842 match data {1843 CreateItemData::NFT(data) => {1844 let item = NftItemType {1845 owner: owner.clone(),1846 const_data: data.const_data.into_inner(),1847 variable_data: data.variable_data.into_inner(),1848 };18491850 Self::add_nft_item(collection, item)?;1851 }1852 CreateItemData::Fungible(data) => {1853 Self::add_fungible_item(collection, owner, data.value)?;1854 }1855 CreateItemData::ReFungible(data) => {1856 let owner_list = vec![Ownership {1857 owner: owner.clone(),1858 fraction: data.pieces,1859 }];18601861 let item = ReFungibleItemType {1862 owner: owner_list,1863 const_data: data.const_data.into_inner(),1864 variable_data: data.variable_data.into_inner(),1865 };18661867 Self::add_refungible_item(collection, item)?;1868 }1869 };18701871 Ok(())1872 }18731874 fn add_fungible_item(1875 collection: &CollectionHandle<T>,1876 owner: &T::CrossAccountId,1877 value: u128,1878 ) -> DispatchResult {1879 let collection_id = collection.id;18801881 1882 collection.consume_sload()?;1883 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;18841885 1886 let item = FungibleItemType {1887 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1888 };1889 collection.consume_sstore()?;1890 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18911892 1893 collection.consume_sload()?;1894 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1895 .checked_add(value)1896 .ok_or(Error::<T>::NumOverflow)?;1897 collection.consume_sstore()?;1898 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18991900 collection.log(ERC20Events::Transfer {1901 from: H160::default(),1902 to: *owner.as_eth(),1903 value: value.into(),1904 })?;1905 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1906 Ok(())1907 }19081909 fn add_refungible_item(1910 collection: &CollectionHandle<T>,1911 item: ReFungibleItemType<T::CrossAccountId>,1912 ) -> DispatchResult {1913 let collection_id = collection.id;19141915 let current_index = <ItemListIndex>::get(collection_id)1916 .checked_add(1)1917 .ok_or(Error::<T>::NumOverflow)?;1918 let itemcopy = item.clone();19191920 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1921 let item_owner = item.owner.first().expect("only one owner is defined");19221923 let value = item_owner.fraction;1924 let owner = item_owner.owner.clone();19251926 Self::add_token_index(collection, current_index, &owner)?;19271928 <ItemListIndex>::insert(collection_id, current_index);1929 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19301931 1932 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1933 .checked_add(value)1934 .ok_or(Error::<T>::NumOverflow)?;1935 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19361937 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1938 Ok(())1939 }19401941 fn add_nft_item(1942 collection: &CollectionHandle<T>,1943 item: NftItemType<T::CrossAccountId>,1944 ) -> DispatchResult {1945 let collection_id = collection.id;19461947 let current_index = <ItemListIndex>::get(collection_id)1948 .checked_add(1)1949 .ok_or(Error::<T>::NumOverflow)?;19501951 let item_owner = item.owner.clone();1952 Self::add_token_index(collection, current_index, &item.owner)?;19531954 <ItemListIndex>::insert(collection_id, current_index);1955 <NftItemList<T>>::insert(collection_id, current_index, item);19561957 1958 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1959 .checked_add(1)1960 .ok_or(Error::<T>::NumOverflow)?;1961 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);19621963 collection.log(ERC721Events::Transfer {1964 from: H160::default(),1965 to: *item_owner.as_eth(),1966 token_id: current_index.into(),1967 })?;1968 Self::deposit_event(RawEvent::ItemCreated(1969 collection_id,1970 current_index,1971 item_owner,1972 ));1973 Ok(())1974 }19751976 fn burn_refungible_item(1977 collection: &CollectionHandle<T>,1978 item_id: TokenId,1979 owner: &T::CrossAccountId,1980 value: u128,1981 ) -> DispatchResult {1982 let collection_id = collection.id;19831984 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1985 .ok_or(Error::<T>::TokenNotFound)?;1986 let mut rft_balance = token1987 .owner1988 .iter()1989 .find(|&i| i.owner == *owner)1990 .ok_or(Error::<T>::TokenNotFound)?1991 .clone();1992 Self::remove_token_index(collection, item_id, owner)?;19931994 1995 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1996 .checked_sub(value)1997 .ok_or(Error::<T>::NumOverflow)?;1998 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19992000 rft_balance.fraction = (rft_balance.fraction)2001 .checked_sub(value)2002 .ok_or(Error::<T>::NumOverflow)?;20032004 let index = token2005 .owner2006 .iter()2007 .position(|i| i.owner == *owner)2008 .expect("owned item is exists");2009 if rft_balance.fraction == 0 {2010 2011 token.owner.remove(index);2012 } else {2013 token.owner[index] = rft_balance;2014 }20152016 let owner_count = token.owner.len();20172018 2019 if owner_count == 0 {2020 <ReFungibleItemList<T>>::remove(collection_id, item_id);2021 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2022 } else {2023 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2024 }20252026 Ok(())2027 }20282029 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2030 let collection_id = collection.id;20312032 let item =2033 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;2034 Self::remove_token_index(collection, item_id, &item.owner)?;20352036 2037 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2038 .checked_sub(1)2039 .ok_or(Error::<T>::NumOverflow)?;2040 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2041 <NftItemList<T>>::remove(collection_id, item_id);2042 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20432044 collection.log(ERC721Events::Transfer {2045 from: *item.owner.as_eth(),2046 to: H160::default(),2047 token_id: item_id.into(),2048 })?;2049 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2050 Ok(())2051 }20522053 fn burn_fungible_item(2054 collection: &CollectionHandle<T>,2055 owner: &T::CrossAccountId,2056 value: u128,2057 ) -> DispatchResult {2058 let collection_id = collection.id;20592060 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2061 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20622063 2064 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2065 .checked_sub(value)2066 .ok_or(Error::<T>::NumOverflow)?;2067 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20682069 if balance.value - value > 0 {2070 balance.value -= value;2071 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2072 } else {2073 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2074 }20752076 collection.log(ERC20Events::Transfer {2077 from: *owner.as_eth(),2078 to: H160::default(),2079 value: value.into(),2080 })?;2081 Ok(())2082 }20832084 pub fn get_collection(2085 collection_id: CollectionId,2086 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2087 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)2088 }20892090 fn check_owner_permissions(2091 target_collection: &CollectionHandle<T>,2092 subject: &T::AccountId,2093 ) -> DispatchResult {2094 ensure!(2095 *subject == target_collection.owner,2096 Error::<T>::NoPermission2097 );20982099 Ok(())2100 }21012102 fn is_owner_or_admin_permissions(2103 collection: &CollectionHandle<T>,2104 subject: &T::CrossAccountId,2105 ) -> Result<bool, DispatchError> {2106 collection.consume_sload()?;2107 Ok(*subject.as_sub() == collection.owner2108 || <AdminList<T>>::get(collection.id).contains(subject))2109 }21102111 fn check_owner_or_admin_permissions(2112 collection: &CollectionHandle<T>,2113 subject: &T::CrossAccountId,2114 ) -> DispatchResult {2115 ensure!(2116 Self::is_owner_or_admin_permissions(collection, subject)?,2117 Error::<T>::NoPermission2118 );21192120 Ok(())2121 }21222123 fn owned_amount(2124 subject: &T::CrossAccountId,2125 collection: &CollectionHandle<T>,2126 item_id: TokenId,2127 ) -> Result<Option<u128>, DispatchError> {2128 collection.consume_sload()?;2129 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2130 }21312132 fn owned_amount_unchecked(2133 subject: &T::CrossAccountId,2134 target_collection: &CollectionHandle<T>,2135 item_id: TokenId,2136 ) -> Option<u128> {2137 let collection_id = target_collection.id;21382139 match target_collection.mode {2140 CollectionMode::NFT => {2141 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2142 }2143 CollectionMode::Fungible(_) => {2144 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2145 }2146 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2147 .owner2148 .iter()2149 .find(|i| i.owner == *subject)2150 .map(|i| i.fraction),2151 }2152 }21532154 fn is_item_owner(2155 subject: &T::CrossAccountId,2156 target_collection: &CollectionHandle<T>,2157 item_id: TokenId,2158 ) -> Result<bool, DispatchError> {2159 Ok(match target_collection.mode {2160 CollectionMode::Fungible(_) => true,2161 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2162 })2163 }21642165 fn check_white_list(2166 collection: &CollectionHandle<T>,2167 address: &T::CrossAccountId,2168 ) -> DispatchResult {2169 collection.consume_sload()?;2170 ensure!(2171 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2172 Error::<T>::AddresNotInWhiteList,2173 );2174 Ok(())2175 }21762177 2178 2179 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2180 let collection_id = target_collection.id;2181 let exists = match target_collection.mode {2182 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2183 CollectionMode::Fungible(_) => true,2184 CollectionMode::ReFungible => {2185 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2186 }2187 };21882189 ensure!(exists, Error::<T>::TokenNotFound);2190 Ok(())2191 }21922193 fn transfer_fungible(2194 collection: &CollectionHandle<T>,2195 value: u128,2196 owner: &T::CrossAccountId,2197 recipient: &T::CrossAccountId,2198 ) -> DispatchResult {2199 let collection_id = collection.id;22002201 collection.consume_sload()?;2202 collection.consume_sload()?;2203 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2204 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());22052206 recipient_balance.value = recipient_balance2207 .value2208 .checked_add(value)2209 .ok_or(Error::<T>::NumOverflow)?;2210 balance.value = balance2211 .value2212 .checked_sub(value)2213 .ok_or(Error::<T>::TokenValueTooLow)?;22142215 2216 collection.consume_sstore()?;2217 collection.consume_sstore()?;2218 if balance.value != 0 {2219 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2220 } else {2221 <Balance<T>>::remove(collection_id, owner.as_sub());2222 }2223 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);22242225 2226 collection.consume_sstore()?;2227 collection.consume_sstore()?;2228 if balance.value != 0 {2229 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2230 } else {2231 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2232 }2233 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);22342235 collection.log(ERC20Events::Transfer {2236 from: *owner.as_eth(),2237 to: *recipient.as_eth(),2238 value: value.into(),2239 })?;2240 Self::deposit_event(RawEvent::Transfer(2241 collection.id,2242 1,2243 owner.clone(),2244 recipient.clone(),2245 value,2246 ));22472248 Ok(())2249 }22502251 fn transfer_refungible(2252 collection: &CollectionHandle<T>,2253 item_id: TokenId,2254 value: u128,2255 owner: T::CrossAccountId,2256 new_owner: T::CrossAccountId,2257 ) -> DispatchResult {2258 let collection_id = collection.id;2259 collection.consume_sload()?;2260 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2261 .ok_or(Error::<T>::TokenNotFound)?;22622263 let item = full_item2264 .owner2265 .iter()2266 .find(|i| i.owner == owner)2267 .ok_or(Error::<T>::TokenNotFound)?;2268 let amount = item.fraction;22692270 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22712272 collection.consume_sload()?;2273 2274 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2275 .checked_sub(value)2276 .ok_or(Error::<T>::NumOverflow)?;2277 collection.consume_sstore()?;2278 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22792280 collection.consume_sload()?;2281 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2282 .checked_add(value)2283 .ok_or(Error::<T>::NumOverflow)?;2284 collection.consume_sstore()?;2285 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22862287 let old_owner = item.owner.clone();2288 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22892290 let mut new_full_item = full_item.clone();2291 2292 if amount == value && !new_owner_has_account {2293 2294 2295 new_full_item2296 .owner2297 .iter_mut()2298 .find(|i| i.owner == owner)2299 .expect("old owner does present in refungible")2300 .owner = new_owner.clone();2301 collection.consume_sstore()?;2302 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23032304 2305 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2306 } else {2307 new_full_item2308 .owner2309 .iter_mut()2310 .find(|i| i.owner == owner)2311 .expect("old owner does present in refungible")2312 .fraction -= value;23132314 2315 if new_owner_has_account {2316 2317 new_full_item2318 .owner2319 .iter_mut()2320 .find(|i| i.owner == new_owner)2321 .expect("new owner has account")2322 .fraction += value;2323 } else {2324 2325 new_full_item.owner.push(Ownership {2326 owner: new_owner.clone(),2327 fraction: value,2328 });2329 Self::add_token_index(collection, item_id, &new_owner)?;2330 }23312332 collection.consume_sstore()?;2333 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2334 }23352336 Self::deposit_event(RawEvent::Transfer(2337 collection.id,2338 item_id,2339 owner,2340 new_owner,2341 amount,2342 ));23432344 Ok(())2345 }23462347 fn transfer_nft(2348 collection: &CollectionHandle<T>,2349 item_id: TokenId,2350 sender: T::CrossAccountId,2351 new_owner: T::CrossAccountId,2352 ) -> DispatchResult {2353 let collection_id = collection.id;2354 collection.consume_sload()?;2355 let mut item =2356 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23572358 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);23592360 collection.consume_sload()?;2361 2362 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2363 .checked_sub(1)2364 .ok_or(Error::<T>::NumOverflow)?;2365 collection.consume_sstore()?;2366 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23672368 collection.consume_sload()?;2369 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2370 .checked_add(1)2371 .ok_or(Error::<T>::NumOverflow)?;2372 collection.consume_sstore()?;2373 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23742375 2376 let old_owner = item.owner.clone();2377 item.owner = new_owner.clone();2378 collection.consume_sstore()?;2379 <NftItemList<T>>::insert(collection_id, item_id, item);23802381 2382 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;23832384 collection.log(ERC721Events::Transfer {2385 from: *sender.as_eth(),2386 to: *new_owner.as_eth(),2387 token_id: item_id.into(),2388 })?;2389 Self::deposit_event(RawEvent::Transfer(2390 collection.id,2391 item_id,2392 sender,2393 new_owner,2394 1,2395 ));23962397 Ok(())2398 }23992400 fn set_re_fungible_variable_data(2401 collection: &CollectionHandle<T>,2402 item_id: TokenId,2403 data: Vec<u8>,2404 ) -> DispatchResult {2405 let collection_id = collection.id;2406 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2407 .ok_or(Error::<T>::TokenNotFound)?;24082409 item.variable_data = data;24102411 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24122413 Ok(())2414 }24152416 fn set_nft_variable_data(2417 collection: &CollectionHandle<T>,2418 item_id: TokenId,2419 data: Vec<u8>,2420 ) -> DispatchResult {2421 let collection_id = collection.id;2422 let mut item =2423 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;24242425 item.variable_data = data;24262427 <NftItemList<T>>::insert(collection_id, item_id, item);24282429 Ok(())2430 }24312432 #[allow(dead_code)]2433 fn init_collection(item: &Collection<T>) {2434 2435 assert!(2436 item.decimal_points <= MAX_DECIMAL_POINTS,2437 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2438 );2439 assert!(2440 item.name.len() <= 64,2441 "Collection name can not be longer than 63 char"2442 );2443 assert!(2444 item.name.len() <= 256,2445 "Collection description can not be longer than 255 char"2446 );2447 assert!(2448 item.token_prefix.len() <= 16,2449 "Token prefix can not be longer than 15 char"2450 );24512452 2453 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();24542455 CreatedCollectionCount::put(next_id);2456 }24572458 #[allow(dead_code)]2459 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2460 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24612462 Self::add_token_index(2463 &CollectionHandle::get(collection_id).unwrap(),2464 current_index,2465 &item.owner,2466 )2467 .unwrap();24682469 <ItemListIndex>::insert(collection_id, current_index);24702471 2472 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2473 .checked_add(1)2474 .unwrap();2475 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2476 }24772478 #[allow(dead_code)]2479 fn init_fungible_token(2480 collection_id: CollectionId,2481 owner: &T::CrossAccountId,2482 item: &FungibleItemType,2483 ) {2484 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24852486 Self::add_token_index(2487 &CollectionHandle::get(collection_id).unwrap(),2488 current_index,2489 owner,2490 )2491 .unwrap();24922493 <ItemListIndex>::insert(collection_id, current_index);24942495 2496 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2497 .checked_add(item.value)2498 .unwrap();2499 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2500 }25012502 #[allow(dead_code)]2503 fn init_refungible_token(2504 collection_id: CollectionId,2505 item: &ReFungibleItemType<T::CrossAccountId>,2506 ) {2507 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();25082509 let value = item.owner.first().unwrap().fraction;2510 let owner = item.owner.first().unwrap().owner.clone();25112512 Self::add_token_index(2513 &CollectionHandle::get(collection_id).unwrap(),2514 current_index,2515 &owner,2516 )2517 .unwrap();25182519 <ItemListIndex>::insert(collection_id, current_index);25202521 2522 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2523 .checked_add(value)2524 .unwrap();2525 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2526 }25272528 fn add_token_index(2529 collection: &CollectionHandle<T>,2530 item_index: TokenId,2531 owner: &T::CrossAccountId,2532 ) -> DispatchResult {2533 collection.consume_sload()?;2534 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2535 if list_exists {2536 collection.consume_sload()?;2537 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());25382539 2540 let account_items: u32 = list.len() as u32;2541 ensure!(2542 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2543 Error::<T>::AddressOwnershipLimitExceeded2544 );25452546 let item_contains = list.contains(&item_index.clone());25472548 if !item_contains {2549 list.push(item_index);2550 }25512552 collection.consume_sstore()?;2553 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2554 } else {2555 let itm = vec![item_index];2556 collection.consume_sstore()?;2557 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2558 }25592560 Ok(())2561 }25622563 fn remove_token_index(2564 collection: &CollectionHandle<T>,2565 item_index: TokenId,2566 owner: &T::CrossAccountId,2567 ) -> DispatchResult {2568 collection.consume_sload()?;2569 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2570 if list_exists {2571 collection.consume_sload()?;2572 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2573 let item_contains = list.contains(&item_index.clone());25742575 if item_contains {2576 list.retain(|&item| item != item_index);2577 collection.consume_sstore()?;2578 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2579 }2580 }25812582 Ok(())2583 }25842585 fn move_token_index(2586 collection: &CollectionHandle<T>,2587 item_index: TokenId,2588 old_owner: &T::CrossAccountId,2589 new_owner: &T::CrossAccountId,2590 ) -> DispatchResult {2591 Self::remove_token_index(collection, item_index, old_owner)?;2592 Self::add_token_index(collection, item_index, new_owner)?;25932594 Ok(())2595 }2596}25972598sp_api::decl_runtime_apis! {2599 pub trait NftApi {2600 2601 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2602 }2603}