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)?;996997 target_collection.submit_logs()998 }9991000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 #[weight = <SelfWeightOf<T>>::transfer()]1024 #[transactional]1025 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027 let collection = Self::get_collection(collection_id)?;10281029 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031 collection.submit_logs()1032 }10331034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 #[weight = <SelfWeightOf<T>>::approve()]1050 #[transactional]1051 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053 let collection = Self::get_collection(collection_id)?;10541055 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057 collection.submit_logs()1058 }10591060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 #[weight = <SelfWeightOf<T>>::transfer_from()]1080 #[transactional]1081 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083 let collection = Self::get_collection(collection_id)?;10841085 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087 collection.submit_logs()1088 }1089 1090 1091 1092 1093 10941095 10961097 10981099 1100 11011102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115 #[transactional]1116 pub fn set_variable_meta_data (1117 origin,1118 collection_id: CollectionId,1119 item_id: TokenId,1120 data: Vec<u8>1121 ) -> DispatchResult {1122 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124 let collection = Self::get_collection(collection_id)?;1125 Self::meta_update_check(&sender, &collection, item_id)?;11261127 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129 Ok(())1130 }11311132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 #[weight = <SelfWeightOf<T>>::set_schema_version()]1147 #[transactional]1148 pub fn set_schema_version(1149 origin,1150 collection_id: CollectionId,1151 version: SchemaVersion1152 ) -> DispatchResult {1153 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154 let mut target_collection = Self::get_collection(collection_id)?;1155 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156 target_collection.schema_version = version;1157 target_collection.save()1158 }11591160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173 #[transactional]1174 pub fn set_offchain_schema(1175 origin,1176 collection_id: CollectionId,1177 schema: Vec<u8>1178 ) -> DispatchResult {1179 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180 let mut target_collection = Self::get_collection(collection_id)?;1181 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183 1184 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186 target_collection.offchain_schema = schema;1187 target_collection.save()1188 }11891190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203 #[transactional]1204 pub fn set_const_on_chain_schema (1205 origin,1206 collection_id: CollectionId,1207 schema: Vec<u8>1208 ) -> DispatchResult {1209 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210 let mut target_collection = Self::get_collection(collection_id)?;1211 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213 1214 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216 target_collection.const_on_chain_schema = schema;1217 target_collection.save()1218 }12191220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233 #[transactional]1234 pub fn set_variable_on_chain_schema (1235 origin,1236 collection_id: CollectionId,1237 schema: Vec<u8>1238 ) -> DispatchResult {1239 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240 let mut target_collection = Self::get_collection(collection_id)?;1241 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243 1244 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246 target_collection.variable_on_chain_schema = schema;1247 target_collection.save()1248 }12491250 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1251 #[transactional]1252 pub fn set_collection_limits(1253 origin,1254 collection_id: u32,1255 new_limits: CollectionLimits<T::BlockNumber>,1256 ) -> DispatchResult {1257 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258 let mut target_collection = Self::get_collection(collection_id)?;1259 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260 let old_limits = &target_collection.limits;12611262 1263 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266 Error::<T>::CollectionLimitBoundsExceeded);12671268 1269 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272 ensure!(1273 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275 Error::<T>::OwnerPermissionsCantBeReverted,1276 );12771278 target_collection.limits = new_limits;12791280 target_collection.save()1281 }1282 }1283}12841285impl<T: Config> Module<T> {1286 pub fn create_item_internal(1287 sender: &T::CrossAccountId,1288 collection: &CollectionHandle<T>,1289 owner: &T::CrossAccountId,1290 data: CreateItemData,1291 ) -> DispatchResult {1292 ensure!(1293 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294 Error::<T>::AddressIsZero1295 );12961297 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298 Self::validate_create_item_args(collection, &data)?;1299 Self::create_item_no_validation(collection, owner, data)?;13001301 Ok(())1302 }13031304 pub fn transfer_internal(1305 sender: &T::CrossAccountId,1306 recipient: &T::CrossAccountId,1307 target_collection: &CollectionHandle<T>,1308 item_id: TokenId,1309 value: u128,1310 ) -> DispatchResult {1311 ensure!(1312 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313 Error::<T>::AddressIsZero1314 );13151316 1317 Self::is_correct_transfer(target_collection, recipient)?;13181319 1320 ensure!(1321 Self::is_item_owner(sender, target_collection, item_id)?1322 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1323 Error::<T>::NoPermission1324 );13251326 if target_collection.access == AccessMode::WhiteList {1327 Self::check_white_list(target_collection, sender)?;1328 Self::check_white_list(target_collection, recipient)?;1329 }13301331 match target_collection.mode {1332 CollectionMode::NFT => Self::transfer_nft(1333 target_collection,1334 item_id,1335 sender.clone(),1336 recipient.clone(),1337 )?,1338 CollectionMode::Fungible(_) => {1339 Self::transfer_fungible(target_collection, value, sender, recipient)?1340 }1341 CollectionMode::ReFungible => Self::transfer_refungible(1342 target_collection,1343 item_id,1344 value,1345 sender.clone(),1346 recipient.clone(),1347 )?,1348 };13491350 Self::deposit_event(RawEvent::Transfer(1351 target_collection.id,1352 item_id,1353 sender.clone(),1354 recipient.clone(),1355 value,1356 ));13571358 Ok(())1359 }13601361 pub fn approve_internal(1362 sender: &T::CrossAccountId,1363 spender: &T::CrossAccountId,1364 collection: &CollectionHandle<T>,1365 item_id: TokenId,1366 amount: u128,1367 ) -> DispatchResult {1368 Self::token_exists(collection, item_id)?;13691370 1371 let bypasses_limits = collection.limits.owner_can_transfer1372 && Self::is_owner_or_admin_permissions(collection, sender)?;13731374 let allowance_limit = if bypasses_limits {1375 None1376 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377 Some(amount)1378 } else {1379 fail!(Error::<T>::NoPermission);1380 };13811382 if collection.access == AccessMode::WhiteList {1383 Self::check_white_list(collection, sender)?;1384 Self::check_white_list(collection, spender)?;1385 }13861387 collection.consume_sload()?;1388 let allowance: u128 = amount1389 .checked_add(<Allowances<T>>::get(1390 collection.id,1391 (item_id, sender.as_sub(), spender.as_sub()),1392 ))1393 .ok_or(Error::<T>::NumOverflow)?;1394 if let Some(limit) = allowance_limit {1395 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396 }1397 collection.consume_sstore()?;1398 <Allowances<T>>::insert(1399 collection.id,1400 (item_id, sender.as_sub(), spender.as_sub()),1401 allowance,1402 );14031404 if matches!(collection.mode, CollectionMode::NFT) {1405 1406 collection.log(ERC721Events::Approval {1407 owner: *sender.as_eth(),1408 approved: *spender.as_eth(),1409 token_id: item_id.into(),1410 })?;1411 }14121413 if matches!(collection.mode, CollectionMode::Fungible(_)) {1414 1415 collection.log(ERC20Events::Approval {1416 owner: *sender.as_eth(),1417 spender: *spender.as_eth(),1418 value: allowance.into(),1419 })?;1420 }14211422 Self::deposit_event(RawEvent::Approved(1423 collection.id,1424 item_id,1425 sender.clone(),1426 spender.clone(),1427 allowance,1428 ));1429 Ok(())1430 }14311432 pub fn transfer_from_internal(1433 sender: &T::CrossAccountId,1434 from: &T::CrossAccountId,1435 recipient: &T::CrossAccountId,1436 collection: &CollectionHandle<T>,1437 item_id: TokenId,1438 amount: u128,1439 ) -> DispatchResult {1440 if sender == from {1441 1442 return Self::transfer_internal(from, recipient, collection, item_id, amount);1443 }14441445 1446 collection.consume_sload()?;1447 let approval: u128 =1448 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450 1451 Self::is_correct_transfer(collection, recipient)?;14521453 1454 ensure!(1455 approval >= amount1456 || (collection.limits.owner_can_transfer1457 && Self::is_owner_or_admin_permissions(collection, sender)?),1458 Error::<T>::NoPermission1459 );14601461 if collection.access == AccessMode::WhiteList {1462 Self::check_white_list(collection, sender)?;1463 Self::check_white_list(collection, recipient)?;1464 }14651466 1467 let allowance = approval.saturating_sub(amount);1468 collection.consume_sstore()?;1469 if allowance > 0 {1470 <Allowances<T>>::insert(1471 collection.id,1472 (item_id, from.as_sub(), sender.as_sub()),1473 allowance,1474 );1475 } else {1476 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477 }14781479 match collection.mode {1480 CollectionMode::NFT => {1481 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482 }1483 CollectionMode::Fungible(_) => {1484 Self::transfer_fungible(collection, amount, from, recipient)?1485 }1486 CollectionMode::ReFungible => Self::transfer_refungible(1487 collection,1488 item_id,1489 amount,1490 from.clone(),1491 recipient.clone(),1492 )?,1493 };14941495 if matches!(collection.mode, CollectionMode::Fungible(_)) {1496 collection.log(ERC20Events::Approval {1497 owner: *from.as_eth(),1498 spender: *sender.as_eth(),1499 value: allowance.into(),1500 })?;1501 }15021503 Ok(())1504 }15051506 pub fn set_variable_meta_data_internal(1507 sender: &T::CrossAccountId,1508 collection: &CollectionHandle<T>,1509 item_id: TokenId,1510 data: Vec<u8>,1511 ) -> DispatchResult {1512 Self::token_exists(collection, item_id)?;15131514 ensure!(1515 CUSTOM_DATA_LIMIT >= data.len() as u32,1516 Error::<T>::TokenVariableDataLimitExceeded1517 );15181519 ensure!(1520 (Self::is_item_owner(sender, collection, item_id)?1521 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1522 || (Self::is_owner_or_admin_permissions(collection, sender)?1523 && collection.meta_update_permission == MetaUpdatePermission::Admin),1524 Error::<T>::NoPermission1525 );15261527 match collection.mode {1528 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1529 CollectionMode::ReFungible => {1530 Self::set_re_fungible_variable_data(collection, item_id, data)?1531 }1532 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1533 };15341535 Ok(())1536 }15371538 pub fn meta_update_check(1539 sender: &T::CrossAccountId,1540 collection: &CollectionHandle<T>,1541 item_id: TokenId,1542 ) -> DispatchResult {1543 match collection.meta_update_permission {1544 MetaUpdatePermission::ItemOwner => ensure!(1545 Self::is_item_owner(sender, collection, item_id)?,1546 Error::<T>::NoPermission1547 ),1548 MetaUpdatePermission::Admin => ensure!(1549 Self::is_owner_or_admin_permissions(collection, sender)?,1550 Error::<T>::NoPermission1551 ),1552 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1553 }15541555 Ok(())1556 }15571558 pub fn get_variable_metadata(1559 collection: &CollectionHandle<T>,1560 item_id: TokenId,1561 ) -> Result<Vec<u8>, DispatchError> {1562 Ok(match collection.mode {1563 CollectionMode::NFT => {1564 <NftItemList<T>>::get(collection.id, item_id)1565 .ok_or(Error::<T>::TokenNotFound)?1566 .variable_data1567 }1568 CollectionMode::ReFungible => {1569 <ReFungibleItemList<T>>::get(collection.id, item_id)1570 .ok_or(Error::<T>::TokenNotFound)?1571 .variable_data1572 }1573 _ => fail!(Error::<T>::UnexpectedCollectionType),1574 })1575 }15761577 pub fn create_multiple_items_internal(1578 sender: &T::CrossAccountId,1579 collection: &CollectionHandle<T>,1580 owner: &T::CrossAccountId,1581 items_data: Vec<CreateItemData>,1582 ) -> DispatchResult {1583 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15841585 for data in &items_data {1586 Self::validate_create_item_args(collection, data)?;1587 }1588 for data in &items_data {1589 Self::create_item_no_validation(collection, owner, data.clone())?;1590 }15911592 Ok(())1593 }15941595 pub fn burn_item_internal(1596 sender: &T::CrossAccountId,1597 collection: &CollectionHandle<T>,1598 item_id: TokenId,1599 value: u128,1600 ) -> DispatchResult {1601 ensure!(1602 Self::is_item_owner(sender, collection, item_id)?1603 || (collection.limits.owner_can_transfer1604 && Self::is_owner_or_admin_permissions(collection, sender)?),1605 Error::<T>::NoPermission1606 );16071608 if collection.access == AccessMode::WhiteList {1609 Self::check_white_list(collection, sender)?;1610 }16111612 match collection.mode {1613 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1614 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1615 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1616 };16171618 Ok(())1619 }16201621 pub fn toggle_white_list_internal(1622 sender: &T::CrossAccountId,1623 collection: &CollectionHandle<T>,1624 address: &T::CrossAccountId,1625 whitelisted: bool,1626 ) -> DispatchResult {1627 Self::check_owner_or_admin_permissions(collection, sender)?;16281629 if whitelisted {1630 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1631 } else {1632 <WhiteList<T>>::remove(collection.id, address.as_sub());1633 }16341635 Ok(())1636 }16371638 fn is_correct_transfer(1639 collection: &CollectionHandle<T>,1640 recipient: &T::CrossAccountId,1641 ) -> DispatchResult {1642 let collection_id = collection.id;16431644 1645 collection.consume_sload()?;1646 let account_items: u32 =1647 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16481649 1650 1651 let limit = if collection.limits.account_token_ownership_limit == 01652 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1653 {1654 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1655 } else {1656 collection.limits.account_token_ownership_limit1657 };16581659 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16601661 1662 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16631664 Ok(())1665 }16661667 fn can_create_items_in_collection(1668 collection: &CollectionHandle<T>,1669 sender: &T::CrossAccountId,1670 owner: &T::CrossAccountId,1671 amount: u32,1672 ) -> DispatchResult {1673 let collection_id = collection.id;16741675 1676 let total_items: u32 = ItemListIndex::get(collection_id)1677 .checked_add(amount)1678 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1679 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1680 as u32)1681 .checked_add(amount)1682 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16831684 1685 1686 let account_token_limit = if collection.limits.account_token_ownership_limit == 01687 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1688 {1689 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1690 } else {1691 collection.limits.account_token_ownership_limit1692 };16931694 ensure!(1695 collection.limits.token_limit >= total_items,1696 Error::<T>::CollectionTokenLimitExceeded1697 );1698 ensure!(1699 account_token_limit >= account_items,1700 Error::<T>::AccountTokenLimitExceeded1701 );17021703 if !Self::is_owner_or_admin_permissions(collection, sender)? {1704 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1705 Self::check_white_list(collection, owner)?;1706 Self::check_white_list(collection, sender)?;1707 }17081709 Ok(())1710 }17111712 fn validate_create_item_args(1713 target_collection: &CollectionHandle<T>,1714 data: &CreateItemData,1715 ) -> DispatchResult {1716 match target_collection.mode {1717 CollectionMode::NFT => {1718 if !matches!(data, CreateItemData::NFT(_)) {1719 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1720 }1721 }1722 CollectionMode::Fungible(_) => {1723 if !matches!(data, CreateItemData::Fungible(_)) {1724 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1725 }1726 }1727 CollectionMode::ReFungible => {1728 if let CreateItemData::ReFungible(data) = data {1729 1730 ensure!(1731 data.pieces <= MAX_REFUNGIBLE_PIECES,1732 Error::<T>::WrongRefungiblePieces1733 );1734 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1735 } else {1736 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1737 }1738 }1739 };17401741 Ok(())1742 }17431744 fn create_item_no_validation(1745 collection: &CollectionHandle<T>,1746 owner: &T::CrossAccountId,1747 data: CreateItemData,1748 ) -> DispatchResult {1749 match data {1750 CreateItemData::NFT(data) => {1751 let item = NftItemType {1752 owner: owner.clone(),1753 const_data: data.const_data.into_inner(),1754 variable_data: data.variable_data.into_inner(),1755 };17561757 Self::add_nft_item(collection, item)?;1758 }1759 CreateItemData::Fungible(data) => {1760 Self::add_fungible_item(collection, owner, data.value)?;1761 }1762 CreateItemData::ReFungible(data) => {1763 let owner_list = vec![Ownership {1764 owner: owner.clone(),1765 fraction: data.pieces,1766 }];17671768 let item = ReFungibleItemType {1769 owner: owner_list,1770 const_data: data.const_data.into_inner(),1771 variable_data: data.variable_data.into_inner(),1772 };17731774 Self::add_refungible_item(collection, item)?;1775 }1776 };17771778 Ok(())1779 }17801781 fn add_fungible_item(1782 collection: &CollectionHandle<T>,1783 owner: &T::CrossAccountId,1784 value: u128,1785 ) -> DispatchResult {1786 let collection_id = collection.id;17871788 1789 collection.consume_sload()?;1790 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17911792 1793 let item = FungibleItemType {1794 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1795 };1796 collection.consume_sstore()?;1797 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17981799 1800 collection.consume_sload()?;1801 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1802 .checked_add(value)1803 .ok_or(Error::<T>::NumOverflow)?;1804 collection.consume_sstore()?;1805 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18061807 collection.log(ERC20Events::Transfer {1808 from: H160::default(),1809 to: *owner.as_eth(),1810 value: value.into(),1811 })?;1812 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1813 Ok(())1814 }18151816 fn add_refungible_item(1817 collection: &CollectionHandle<T>,1818 item: ReFungibleItemType<T::CrossAccountId>,1819 ) -> DispatchResult {1820 let collection_id = collection.id;18211822 let current_index = <ItemListIndex>::get(collection_id)1823 .checked_add(1)1824 .ok_or(Error::<T>::NumOverflow)?;1825 let itemcopy = item.clone();18261827 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1828 let item_owner = item.owner.first().expect("only one owner is defined");18291830 let value = item_owner.fraction;1831 let owner = item_owner.owner.clone();18321833 Self::add_token_index(collection, current_index, &owner)?;18341835 <ItemListIndex>::insert(collection_id, current_index);1836 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18371838 1839 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1840 .checked_add(value)1841 .ok_or(Error::<T>::NumOverflow)?;1842 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18431844 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1845 Ok(())1846 }18471848 fn add_nft_item(1849 collection: &CollectionHandle<T>,1850 item: NftItemType<T::CrossAccountId>,1851 ) -> DispatchResult {1852 let collection_id = collection.id;18531854 let current_index = <ItemListIndex>::get(collection_id)1855 .checked_add(1)1856 .ok_or(Error::<T>::NumOverflow)?;18571858 let item_owner = item.owner.clone();1859 Self::add_token_index(collection, current_index, &item.owner)?;18601861 <ItemListIndex>::insert(collection_id, current_index);1862 <NftItemList<T>>::insert(collection_id, current_index, item);18631864 1865 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1866 .checked_add(1)1867 .ok_or(Error::<T>::NumOverflow)?;1868 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18691870 collection.log(ERC721Events::Transfer {1871 from: H160::default(),1872 to: *item_owner.as_eth(),1873 token_id: current_index.into(),1874 })?;1875 Self::deposit_event(RawEvent::ItemCreated(1876 collection_id,1877 current_index,1878 item_owner,1879 ));1880 Ok(())1881 }18821883 fn burn_refungible_item(1884 collection: &CollectionHandle<T>,1885 item_id: TokenId,1886 owner: &T::CrossAccountId,1887 ) -> DispatchResult {1888 let collection_id = collection.id;18891890 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1891 .ok_or(Error::<T>::TokenNotFound)?;1892 let rft_balance = token1893 .owner1894 .iter()1895 .find(|&i| i.owner == *owner)1896 .ok_or(Error::<T>::TokenNotFound)?;1897 Self::remove_token_index(collection, item_id, owner)?;18981899 1900 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1901 .checked_sub(rft_balance.fraction)1902 .ok_or(Error::<T>::NumOverflow)?;1903 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19041905 1906 let index = token1907 .owner1908 .iter()1909 .position(|i| i.owner == *owner)1910 .expect("owned item is exists");1911 token.owner.remove(index);1912 let owner_count = token.owner.len();19131914 1915 if owner_count == 0 {1916 <ReFungibleItemList<T>>::remove(collection_id, item_id);1917 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1918 } else {1919 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1920 }19211922 Ok(())1923 }19241925 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1926 let collection_id = collection.id;19271928 let item =1929 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1930 Self::remove_token_index(collection, item_id, &item.owner)?;19311932 1933 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1934 .checked_sub(1)1935 .ok_or(Error::<T>::NumOverflow)?;1936 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1937 <NftItemList<T>>::remove(collection_id, item_id);1938 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19391940 collection.log(ERC721Events::Transfer {1941 from: *item.owner.as_eth(),1942 to: H160::default(),1943 token_id: item_id.into(),1944 })?;1945 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1946 Ok(())1947 }19481949 fn burn_fungible_item(1950 owner: &T::CrossAccountId,1951 collection: &CollectionHandle<T>,1952 value: u128,1953 ) -> DispatchResult {1954 let collection_id = collection.id;19551956 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1957 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19581959 1960 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1961 .checked_sub(value)1962 .ok_or(Error::<T>::NumOverflow)?;1963 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19641965 if balance.value - value > 0 {1966 balance.value -= value;1967 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1968 } else {1969 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1970 }19711972 collection.log(ERC20Events::Transfer {1973 from: *owner.as_eth(),1974 to: H160::default(),1975 value: value.into(),1976 })?;1977 Ok(())1978 }19791980 pub fn get_collection(1981 collection_id: CollectionId,1982 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1983 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1984 }19851986 fn check_owner_permissions(1987 target_collection: &CollectionHandle<T>,1988 subject: &T::AccountId,1989 ) -> DispatchResult {1990 ensure!(1991 *subject == target_collection.owner,1992 Error::<T>::NoPermission1993 );19941995 Ok(())1996 }19971998 fn is_owner_or_admin_permissions(1999 collection: &CollectionHandle<T>,2000 subject: &T::CrossAccountId,2001 ) -> Result<bool, DispatchError> {2002 collection.consume_sload()?;2003 Ok(*subject.as_sub() == collection.owner2004 || <AdminList<T>>::get(collection.id).contains(subject))2005 }20062007 fn check_owner_or_admin_permissions(2008 collection: &CollectionHandle<T>,2009 subject: &T::CrossAccountId,2010 ) -> DispatchResult {2011 ensure!(2012 Self::is_owner_or_admin_permissions(collection, subject)?,2013 Error::<T>::NoPermission2014 );20152016 Ok(())2017 }20182019 fn owned_amount(2020 subject: &T::CrossAccountId,2021 collection: &CollectionHandle<T>,2022 item_id: TokenId,2023 ) -> Result<Option<u128>, DispatchError> {2024 collection.consume_sload()?;2025 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2026 }20272028 fn owned_amount_unchecked(2029 subject: &T::CrossAccountId,2030 target_collection: &CollectionHandle<T>,2031 item_id: TokenId,2032 ) -> Option<u128> {2033 let collection_id = target_collection.id;20342035 match target_collection.mode {2036 CollectionMode::NFT => {2037 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2038 }2039 CollectionMode::Fungible(_) => {2040 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2041 }2042 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2043 .owner2044 .iter()2045 .find(|i| i.owner == *subject)2046 .map(|i| i.fraction),2047 }2048 }20492050 fn is_item_owner(2051 subject: &T::CrossAccountId,2052 target_collection: &CollectionHandle<T>,2053 item_id: TokenId,2054 ) -> Result<bool, DispatchError> {2055 Ok(match target_collection.mode {2056 CollectionMode::Fungible(_) => true,2057 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2058 })2059 }20602061 fn check_white_list(2062 collection: &CollectionHandle<T>,2063 address: &T::CrossAccountId,2064 ) -> DispatchResult {2065 collection.consume_sload()?;2066 ensure!(2067 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2068 Error::<T>::AddresNotInWhiteList,2069 );2070 Ok(())2071 }20722073 2074 2075 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2076 let collection_id = target_collection.id;2077 let exists = match target_collection.mode {2078 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2079 CollectionMode::Fungible(_) => true,2080 CollectionMode::ReFungible => {2081 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2082 }2083 };20842085 ensure!(exists, Error::<T>::TokenNotFound);2086 Ok(())2087 }20882089 fn transfer_fungible(2090 collection: &CollectionHandle<T>,2091 value: u128,2092 owner: &T::CrossAccountId,2093 recipient: &T::CrossAccountId,2094 ) -> DispatchResult {2095 let collection_id = collection.id;20962097 collection.consume_sload()?;2098 collection.consume_sload()?;2099 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2100 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21012102 recipient_balance.value = recipient_balance2103 .value2104 .checked_add(value)2105 .ok_or(Error::<T>::NumOverflow)?;2106 balance.value = balance2107 .value2108 .checked_sub(value)2109 .ok_or(Error::<T>::TokenValueTooLow)?;21102111 2112 collection.consume_sstore()?;2113 collection.consume_sstore()?;2114 if balance.value != 0 {2115 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2116 } else {2117 <Balance<T>>::remove(collection_id, owner.as_sub());2118 }2119 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21202121 2122 collection.consume_sstore()?;2123 collection.consume_sstore()?;2124 if balance.value != 0 {2125 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2126 } else {2127 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2128 }2129 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21302131 collection.log(ERC20Events::Transfer {2132 from: *owner.as_eth(),2133 to: *recipient.as_eth(),2134 value: value.into(),2135 })?;2136 Self::deposit_event(RawEvent::Transfer(2137 collection.id,2138 1,2139 owner.clone(),2140 recipient.clone(),2141 value,2142 ));21432144 Ok(())2145 }21462147 fn transfer_refungible(2148 collection: &CollectionHandle<T>,2149 item_id: TokenId,2150 value: u128,2151 owner: T::CrossAccountId,2152 new_owner: T::CrossAccountId,2153 ) -> DispatchResult {2154 let collection_id = collection.id;2155 collection.consume_sload()?;2156 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2157 .ok_or(Error::<T>::TokenNotFound)?;21582159 let item = full_item2160 .owner2161 .iter()2162 .find(|i| i.owner == owner)2163 .ok_or(Error::<T>::TokenNotFound)?;2164 let amount = item.fraction;21652166 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21672168 collection.consume_sload()?;2169 2170 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2171 .checked_sub(value)2172 .ok_or(Error::<T>::NumOverflow)?;2173 collection.consume_sstore()?;2174 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21752176 collection.consume_sload()?;2177 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2178 .checked_add(value)2179 .ok_or(Error::<T>::NumOverflow)?;2180 collection.consume_sstore()?;2181 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21822183 let old_owner = item.owner.clone();2184 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21852186 let mut new_full_item = full_item.clone();2187 2188 if amount == value && !new_owner_has_account {2189 2190 2191 new_full_item2192 .owner2193 .iter_mut()2194 .find(|i| i.owner == owner)2195 .expect("old owner does present in refungible")2196 .owner = new_owner.clone();2197 collection.consume_sstore()?;2198 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21992200 2201 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2202 } else {2203 new_full_item2204 .owner2205 .iter_mut()2206 .find(|i| i.owner == owner)2207 .expect("old owner does present in refungible")2208 .fraction -= value;22092210 2211 if new_owner_has_account {2212 2213 new_full_item2214 .owner2215 .iter_mut()2216 .find(|i| i.owner == new_owner)2217 .expect("new owner has account")2218 .fraction += value;2219 } else {2220 2221 new_full_item.owner.push(Ownership {2222 owner: new_owner.clone(),2223 fraction: value,2224 });2225 Self::add_token_index(collection, item_id, &new_owner)?;2226 }22272228 collection.consume_sstore()?;2229 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2230 }22312232 Self::deposit_event(RawEvent::Transfer(2233 collection.id,2234 item_id,2235 owner,2236 new_owner,2237 amount,2238 ));22392240 Ok(())2241 }22422243 fn transfer_nft(2244 collection: &CollectionHandle<T>,2245 item_id: TokenId,2246 sender: T::CrossAccountId,2247 new_owner: T::CrossAccountId,2248 ) -> DispatchResult {2249 let collection_id = collection.id;2250 collection.consume_sload()?;2251 let mut item =2252 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22532254 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22552256 collection.consume_sload()?;2257 2258 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2259 .checked_sub(1)2260 .ok_or(Error::<T>::NumOverflow)?;2261 collection.consume_sstore()?;2262 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22632264 collection.consume_sload()?;2265 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2266 .checked_add(1)2267 .ok_or(Error::<T>::NumOverflow)?;2268 collection.consume_sstore()?;2269 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22702271 2272 let old_owner = item.owner.clone();2273 item.owner = new_owner.clone();2274 collection.consume_sstore()?;2275 <NftItemList<T>>::insert(collection_id, item_id, item);22762277 2278 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22792280 collection.log(ERC721Events::Transfer {2281 from: *sender.as_eth(),2282 to: *new_owner.as_eth(),2283 token_id: item_id.into(),2284 })?;2285 Self::deposit_event(RawEvent::Transfer(2286 collection.id,2287 item_id,2288 sender,2289 new_owner,2290 1,2291 ));22922293 Ok(())2294 }22952296 fn set_re_fungible_variable_data(2297 collection: &CollectionHandle<T>,2298 item_id: TokenId,2299 data: Vec<u8>,2300 ) -> DispatchResult {2301 let collection_id = collection.id;2302 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2303 .ok_or(Error::<T>::TokenNotFound)?;23042305 item.variable_data = data;23062307 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23082309 Ok(())2310 }23112312 fn set_nft_variable_data(2313 collection: &CollectionHandle<T>,2314 item_id: TokenId,2315 data: Vec<u8>,2316 ) -> DispatchResult {2317 let collection_id = collection.id;2318 let mut item =2319 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23202321 item.variable_data = data;23222323 <NftItemList<T>>::insert(collection_id, item_id, item);23242325 Ok(())2326 }23272328 #[allow(dead_code)]2329 fn init_collection(item: &Collection<T>) {2330 2331 assert!(2332 item.decimal_points <= MAX_DECIMAL_POINTS,2333 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2334 );2335 assert!(2336 item.name.len() <= 64,2337 "Collection name can not be longer than 63 char"2338 );2339 assert!(2340 item.name.len() <= 256,2341 "Collection description can not be longer than 255 char"2342 );2343 assert!(2344 item.token_prefix.len() <= 16,2345 "Token prefix can not be longer than 15 char"2346 );23472348 2349 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23502351 CreatedCollectionCount::put(next_id);2352 }23532354 #[allow(dead_code)]2355 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2356 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23572358 Self::add_token_index(2359 &CollectionHandle::get(collection_id).unwrap(),2360 current_index,2361 &item.owner,2362 )2363 .unwrap();23642365 <ItemListIndex>::insert(collection_id, current_index);23662367 2368 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2369 .checked_add(1)2370 .unwrap();2371 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2372 }23732374 #[allow(dead_code)]2375 fn init_fungible_token(2376 collection_id: CollectionId,2377 owner: &T::CrossAccountId,2378 item: &FungibleItemType,2379 ) {2380 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23812382 Self::add_token_index(2383 &CollectionHandle::get(collection_id).unwrap(),2384 current_index,2385 owner,2386 )2387 .unwrap();23882389 <ItemListIndex>::insert(collection_id, current_index);23902391 2392 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2393 .checked_add(item.value)2394 .unwrap();2395 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2396 }23972398 #[allow(dead_code)]2399 fn init_refungible_token(2400 collection_id: CollectionId,2401 item: &ReFungibleItemType<T::CrossAccountId>,2402 ) {2403 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24042405 let value = item.owner.first().unwrap().fraction;2406 let owner = item.owner.first().unwrap().owner.clone();24072408 Self::add_token_index(2409 &CollectionHandle::get(collection_id).unwrap(),2410 current_index,2411 &owner,2412 )2413 .unwrap();24142415 <ItemListIndex>::insert(collection_id, current_index);24162417 2418 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2419 .checked_add(value)2420 .unwrap();2421 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2422 }24232424 fn add_token_index(2425 collection: &CollectionHandle<T>,2426 item_index: TokenId,2427 owner: &T::CrossAccountId,2428 ) -> DispatchResult {2429 collection.consume_sload()?;2430 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2431 if list_exists {2432 collection.consume_sload()?;2433 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24342435 2436 let account_items: u32 = list.len() as u32;2437 ensure!(2438 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2439 Error::<T>::AddressOwnershipLimitExceeded2440 );24412442 let item_contains = list.contains(&item_index.clone());24432444 if !item_contains {2445 list.push(item_index);2446 }24472448 collection.consume_sstore()?;2449 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2450 } else {2451 let itm = vec![item_index];2452 collection.consume_sstore()?;2453 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2454 }24552456 Ok(())2457 }24582459 fn remove_token_index(2460 collection: &CollectionHandle<T>,2461 item_index: TokenId,2462 owner: &T::CrossAccountId,2463 ) -> DispatchResult {2464 collection.consume_sload()?;2465 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2466 if list_exists {2467 collection.consume_sload()?;2468 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2469 let item_contains = list.contains(&item_index.clone());24702471 if item_contains {2472 list.retain(|&item| item != item_index);2473 collection.consume_sstore()?;2474 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2475 }2476 }24772478 Ok(())2479 }24802481 fn move_token_index(2482 collection: &CollectionHandle<T>,2483 item_index: TokenId,2484 old_owner: &T::CrossAccountId,2485 new_owner: &T::CrossAccountId,2486 ) -> DispatchResult {2487 Self::remove_token_index(collection, item_index, old_owner)?;2488 Self::add_token_index(collection, item_index, new_owner)?;24892490 Ok(())2491 }2492}24932494sp_api::decl_runtime_apis! {2495 pub trait NftApi {2496 2497 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2498 }2499}