123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516pub use frame_support::{17 construct_runtime, decl_event, decl_module, decl_storage, decl_error,18 dispatch::DispatchResult,19 ensure, fail, parameter_types,20 traits::{21 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,22 Randomness, IsSubType, WithdrawReasons,23 },24 weights::{25 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},26 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,27 WeightToFeePolynomial, DispatchClass,28 },29 StorageValue,30 transactional,31};3233use frame_system::{self as system, ensure_signed, ensure_root};34use sp_runtime::sp_std::prelude::Vec;35use core::ops::{Deref, DerefMut};36use nft_data_structs::{37 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,38 AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits,39 CollectionId, CollectionMode, TokenId, 40 SchemaVersion, SponsorshipState, Ownership,41 NftItemType, FungibleItemType, ReFungibleItemType42};4344#[cfg(test)]45mod mock;4647#[cfg(test)]48mod tests;4950mod default_weights;5152#[cfg(feature = "runtime-benchmarks")]53mod benchmarking;5455pub trait WeightInfo {56 fn create_collection() -> Weight;57 fn destroy_collection() -> Weight;58 fn add_to_white_list() -> Weight;59 fn remove_from_white_list() -> Weight;60 fn set_public_access_mode() -> Weight;61 fn set_mint_permission() -> Weight;62 fn change_collection_owner() -> Weight;63 fn add_collection_admin() -> Weight;64 fn remove_collection_admin() -> Weight;65 fn set_collection_sponsor() -> Weight;66 fn confirm_sponsorship() -> Weight;67 fn remove_collection_sponsor() -> Weight;68 fn create_item(s: usize) -> Weight;69 fn burn_item() -> Weight;70 fn transfer() -> Weight;71 fn approve() -> Weight;72 fn transfer_from() -> Weight;73 fn set_offchain_schema() -> Weight;74 fn set_const_on_chain_schema() -> Weight;75 fn set_variable_on_chain_schema() -> Weight;76 fn set_variable_meta_data() -> Weight;77 fn enable_contract_sponsoring() -> Weight;78 fn set_schema_version() -> Weight;79 fn set_chain_limits() -> Weight;80 fn set_contract_sponsoring_rate_limit() -> Weight;81 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;82 fn toggle_contract_white_list() -> Weight;83 fn add_to_contract_white_list() -> Weight;84 fn remove_from_contract_white_list() -> Weight;85 fn set_collection_limits() -> Weight;86}8788decl_error! {89 90 pub enum Error for Module<T: Config> {91 92 TotalCollectionsLimitExceeded,93 94 CollectionDecimalPointLimitExceeded, 95 96 CollectionNameLimitExceeded, 97 98 CollectionDescriptionLimitExceeded, 99 100 CollectionTokenPrefixLimitExceeded,101 102 CollectionNotFound,103 104 TokenNotFound,105 106 AdminNotFound,107 108 NumOverflow, 109 110 AlreadyAdmin, 111 112 NoPermission,113 114 ConfirmUnsetSponsorFail,115 116 PublicMintingNotAllowed,117 118 MustBeTokenOwner,119 120 TokenValueTooLow,121 122 NftSizeLimitExceeded,123 124 ApproveNotFound,125 126 TokenValueNotEnough,127 128 ApproveRequired,129 130 AddresNotInWhiteList,131 132 CollectionAdminsLimitExceeded,133 134 AddressOwnershipLimitExceeded,135 136 EmptyArgument,137 138 TokenConstDataLimitExceeded,139 140 TokenVariableDataLimitExceeded,141 142 NotNftDataUsedToMintNftCollectionToken,143 144 NotFungibleDataUsedToMintFungibleCollectionToken,145 146 NotReFungibleDataUsedToMintReFungibleCollectionToken,147 148 UnexpectedCollectionType,149 150 CantStoreMetadataInFungibleTokens,151 152 CollectionTokenLimitExceeded,153 154 AccountTokenLimitExceeded,155 156 CollectionLimitBoundsExceeded,157 158 OwnerPermissionsCantBeReverted,159 160 SchemaDataLimitExceeded,161 162 WrongRefungiblePieces,163 164 BadCreateRefungibleCall,165 }166}167168pub struct CollectionHandle<T: system::Config> {169 pub id: CollectionId,170 pub collection: Collection<T>,171}172173impl<T: frame_system::Config> Deref for CollectionHandle<T> {174 type Target = Collection<T>;175176 fn deref(&self) -> &Self::Target {177 &self.collection178 }179}180181impl<T: frame_system::Config> DerefMut for CollectionHandle<T> {182 fn deref_mut(&mut self) -> &mut Self::Target {183 &mut self.collection184 }185}186187pub trait Config: system::Config + Sized {188 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;189190 191 type WeightInfo: WeightInfo;192193 type Currency: Currency<Self::AccountId>;194 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;195 type TreasuryAccountId: Get<Self::AccountId>;196}197198199200201202203204205206207208209210211212213214215216217218219220decl_storage! {221 trait Store for Module<T: Config> as Nft {222223 224 225 CreatedCollectionCount: u32;226 227 ChainVersion: u64;228 229 230 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;231 232233 234 pub ChainLimit get(fn chain_limit) config(): ChainLimits;235 236237 238 239 240 DestroyedCollectionCount: u32;241 242 243 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;244 245246 247 248 249 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;250 251 252 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;253 254 255 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;256 257258 259 260 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;261262 263 264 265 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;266267 268 269 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;270 271 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;272 273 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;274 275276 277 278 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;279 280281 282 283 284 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;285 286 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;287 288 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;289 290 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;291 292293 294 295 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;296 297 298 299 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;300 301 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;302 303 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;304 305 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;306 307 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 308 309 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 310 311 }312 add_extra_genesis {313 build(|config: &GenesisConfig<T>| {314 315 for (_num, _c) in &config.collection_id {316 <Module<T>>::init_collection(_c);317 }318319 for (_num, _c, _i) in &config.nft_item_id {320 <Module<T>>::init_nft_token(*_c, _i);321 }322323 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {324 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);325 }326327 for (_num, _c, _i) in &config.refungible_item_id {328 <Module<T>>::init_refungible_token(*_c, _i);329 }330 })331 }332}333334decl_event!(335 pub enum Event<T>336 where337 AccountId = <T as system::Config>::AccountId,338 {339 340 341 342 343 344 345 346 347 348 CollectionCreated(CollectionId, u8, AccountId),349350 351 352 353 354 355 356 357 358 359 ItemCreated(CollectionId, TokenId, AccountId),360361 362 363 364 365 366 367 368 ItemDestroyed(CollectionId, TokenId),369370 371 372 373 374 375 376 377 378 379 380 381 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),382383 384 385 386 387 388 389 390 391 392 Approved(CollectionId, TokenId, AccountId, AccountId, u128),393 }394);395396decl_module! {397 pub struct Module<T: Config> for enum Call 398 where 399 origin: T::Origin400 {401 fn deposit_event() = default;402 type Error = Error<T>;403404 fn on_initialize(_now: T::BlockNumber) -> Weight {405 0406 }407408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 #[weight = <T as Config>::WeightInfo::create_collection()]425 #[transactional]426 pub fn create_collection(origin,427 collection_name: Vec<u16>,428 collection_description: Vec<u16>,429 token_prefix: Vec<u8>,430 mode: CollectionMode) -> DispatchResult {431432 433 let who = ensure_signed(origin)?;434435 436 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();437 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(438 &T::TreasuryAccountId::get(),439 T::CollectionCreationPrice::get(),440 ));441 <T as Config>::Currency::settle(442 &who,443 imbalance,444 WithdrawReasons::TRANSFER,445 ExistenceRequirement::KeepAlive,446 ).map_err(|_| Error::<T>::NoPermission)?;447448 let decimal_points = match mode {449 CollectionMode::Fungible(points) => points,450 _ => 0451 };452453 let chain_limit = ChainLimit::get();454455 let created_count = CreatedCollectionCount::get();456 let destroyed_count = DestroyedCollectionCount::get();457458 459 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);460461 462 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);463 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);464 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);465 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);466467 468 let next_id = created_count469 .checked_add(1)470 .ok_or(Error::<T>::NumOverflow)?;471472 CreatedCollectionCount::put(next_id);473474 let limits = CollectionLimits {475 sponsored_data_size: chain_limit.custom_data_limit,476 ..Default::default()477 };478479 480 let new_collection = Collection {481 owner: who.clone(),482 name: collection_name,483 mode: mode.clone(),484 mint_mode: false,485 access: AccessMode::Normal,486 description: collection_description,487 decimal_points: decimal_points,488 token_prefix: token_prefix,489 offchain_schema: Vec::new(),490 schema_version: SchemaVersion::ImageURL,491 sponsorship: SponsorshipState::Disabled,492 variable_on_chain_schema: Vec::new(),493 const_on_chain_schema: Vec::new(),494 limits,495 };496497 498 <CollectionById<T>>::insert(next_id, new_collection);499500 501 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));502503 Ok(())504 }505506 507 508 509 510 511 512 513 514 515 #[weight = <T as Config>::WeightInfo::destroy_collection()]516 #[transactional]517 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {518519 let sender = ensure_signed(origin)?;520 let collection = Self::get_collection(collection_id)?;521 Self::check_owner_permissions(&collection, sender)?;522 if !collection.limits.owner_can_destroy {523 fail!(Error::<T>::NoPermission);524 }525526 <AddressTokens<T>>::remove_prefix(collection_id);527 <Allowances<T>>::remove_prefix(collection_id);528 <Balance<T>>::remove_prefix(collection_id);529 <ItemListIndex>::remove(collection_id);530 <AdminList<T>>::remove(collection_id);531 <CollectionById<T>>::remove(collection_id);532 <WhiteList<T>>::remove_prefix(collection_id);533534 <NftItemList<T>>::remove_prefix(collection_id);535 <FungibleItemList<T>>::remove_prefix(collection_id);536 <ReFungibleItemList<T>>::remove_prefix(collection_id);537538 <NftTransferBasket<T>>::remove_prefix(collection_id);539 <FungibleTransferBasket<T>>::remove_prefix(collection_id);540 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);541542 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);543544 DestroyedCollectionCount::put(DestroyedCollectionCount::get()545 .checked_add(1)546 .ok_or(Error::<T>::NumOverflow)?);547548 Ok(())549 }550551 552 553 554 555 556 557 558 559 560 561 562 563 #[weight = <T as Config>::WeightInfo::add_to_white_list()]564 #[transactional]565 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{566567 let sender = ensure_signed(origin)?;568 let collection = Self::get_collection(collection_id)?;569570 Self::toggle_white_list_internal(571 &sender,572 &collection,573 &address,574 true,575 )?;576577 Ok(())578 }579580 581 582 583 584 585 586 587 588 589 590 591 592 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]593 #[transactional]594 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{595596 let sender = ensure_signed(origin)?;597 let collection = Self::get_collection(collection_id)?;598599 Self::toggle_white_list_internal(600 &sender,601 &collection,602 &address,603 false,604 )?;605606 Ok(())607 }608609 610 611 612 613 614 615 616 617 618 619 620 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]621 #[transactional]622 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult623 {624 let sender = ensure_signed(origin)?;625626 let mut target_collection = Self::get_collection(collection_id)?;627 Self::check_owner_permissions(&target_collection, sender)?;628 target_collection.access = mode;629 Self::save_collection(target_collection);630631 Ok(())632 }633634 635 636 637 638 639 640 641 642 643 644 645 646 647 #[weight = <T as Config>::WeightInfo::set_mint_permission()]648 #[transactional]649 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult650 {651 let sender = ensure_signed(origin)?;652653 let mut target_collection = Self::get_collection(collection_id)?;654 Self::check_owner_permissions(&target_collection, sender)?;655 target_collection.mint_mode = mint_permission;656 Self::save_collection(target_collection);657658 Ok(())659 }660661 662 663 664 665 666 667 668 669 670 671 672 #[weight = <T as Config>::WeightInfo::change_collection_owner()]673 #[transactional]674 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {675676 let sender = ensure_signed(origin)?;677 let mut target_collection = Self::get_collection(collection_id)?;678 Self::check_owner_permissions(&target_collection, sender)?;679 target_collection.owner = new_owner;680 Self::save_collection(target_collection);681682 Ok(())683 }684685 686 687 688 689 690 691 692 693 694 695 696 697 698 #[weight = <T as Config>::WeightInfo::add_collection_admin()]699 #[transactional]700 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {701702 let sender = ensure_signed(origin)?;703 let collection = Self::get_collection(collection_id)?;704 Self::check_owner_or_admin_permissions(&collection, sender)?;705 let mut admin_arr = <AdminList<T>>::get(collection_id);706707 match admin_arr.binary_search(&new_admin_id) {708 Ok(_) => {},709 Err(idx) => {710 let limits = ChainLimit::get();711 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);712 admin_arr.insert(idx, new_admin_id);713 <AdminList<T>>::insert(collection_id, admin_arr);714 }715 }716 Ok(())717 }718719 720 721 722 723 724 725 726 727 728 729 730 731 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]732 #[transactional]733 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {734735 let sender = ensure_signed(origin)?;736 let collection = Self::get_collection(collection_id)?;737 Self::check_owner_or_admin_permissions(&collection, sender)?;738 let mut admin_arr = <AdminList<T>>::get(collection_id);739740 match admin_arr.binary_search(&account_id) {741 Ok(idx) => {742 admin_arr.remove(idx);743 <AdminList<T>>::insert(collection_id, admin_arr);744 },745 Err(_) => {}746 }747 Ok(())748 }749750 751 752 753 754 755 756 757 758 759 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]760 #[transactional]761 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {762763 let sender = ensure_signed(origin)?;764 let mut target_collection = Self::get_collection(collection_id)?;765 Self::check_owner_permissions(&target_collection, sender)?;766767 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);768 Self::save_collection(target_collection);769770 Ok(())771 }772773 774 775 776 777 778 779 780 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]781 #[transactional]782 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {783784 let sender = ensure_signed(origin)?;785786 let mut target_collection = Self::get_collection(collection_id)?;787 ensure!(788 target_collection.sponsorship.pending_sponsor() == Some(&sender),789 Error::<T>::ConfirmUnsetSponsorFail790 );791792 target_collection.sponsorship = SponsorshipState::Confirmed(sender);793 Self::save_collection(target_collection);794795 Ok(())796 }797798 799 800 801 802 803 804 805 806 807 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]808 #[transactional]809 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {810811 let sender = ensure_signed(origin)?;812813 let mut target_collection = Self::get_collection(collection_id)?;814 Self::check_owner_permissions(&target_collection, sender)?;815816 target_collection.sponsorship = SponsorshipState::Disabled;817 Self::save_collection(target_collection);818819 Ok(())820 }821822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845846 #[weight = <T as Config>::WeightInfo::create_item(data.len())]847 #[transactional]848 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {849 let sender = ensure_signed(origin)?;850 Self::create_item_internal(sender, collection_id, owner, data)851 }852853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()872 .map(|data| { data.len() })873 .sum())]874 #[transactional]875 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {876877 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);878 let sender = ensure_signed(origin)?;879880 let target_collection = Self::get_collection(collection_id)?;881882 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;883884 for data in &items_data {885 Self::validate_create_item_args(&target_collection, data)?;886 }887 for data in &items_data {888 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;889 }890891 Ok(())892 }893894 895 896 897 898 899 900 901 902 903 904 905 906 907 #[weight = <T as Config>::WeightInfo::burn_item()]908 #[transactional]909 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {910911 let sender = ensure_signed(origin)?;912913 914 let target_collection = Self::get_collection(collection_id)?;915 ensure!(916 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||917 (918 target_collection.limits.owner_can_transfer &&919 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())920 ),921 Error::<T>::NoPermission922 );923924 if target_collection.access == AccessMode::WhiteList {925 Self::check_white_list(&target_collection, &sender)?;926 }927928 match target_collection.mode929 {930 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,931 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,932 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,933 _ => ()934 };935936 937 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));938939 Ok(())940 }941942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 #[weight = <T as Config>::WeightInfo::transfer()]966 #[transactional]967 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {968 let sender = ensure_signed(origin)?;969 let collection = Self::get_collection(collection_id)?;970971 Self::transfer_internal(sender, recipient, &collection, item_id, value)972 }973974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 #[weight = <T as Config>::WeightInfo::approve()]990 #[transactional]991 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {992993 let sender = ensure_signed(origin)?;994 let collection = Self::get_collection(collection_id)?;995996 Self::approve_internal(sender, spender, &collection, item_id, amount)?;997998 Ok(())999 }1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 #[weight = <T as Config>::WeightInfo::transfer_from()]1021 #[transactional]1022 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {10231024 let sender = ensure_signed(origin)?;1025 let collection = Self::get_collection(collection_id)?;10261027 Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;10281029 Ok(())1030 }10311032 1033 10341035 1036 1037 1038 10391040 10411042 10431044 1045 10461047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1060 #[transactional]1061 pub fn set_variable_meta_data (1062 origin,1063 collection_id: CollectionId,1064 item_id: TokenId,1065 data: Vec<u8>1066 ) -> DispatchResult {1067 let sender = ensure_signed(origin)?;1068 1069 let collection = Self::get_collection(collection_id)?;10701071 Self::set_variable_meta_data_internal(sender, &collection, item_id, data)?;10721073 Ok(())1074 }1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 #[weight = <T as Config>::WeightInfo::set_schema_version()]1091 #[transactional]1092 pub fn set_schema_version(1093 origin,1094 collection_id: CollectionId,1095 version: SchemaVersion1096 ) -> DispatchResult {1097 let sender = ensure_signed(origin)?;1098 let mut target_collection = Self::get_collection(collection_id)?;1099 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1100 target_collection.schema_version = version;1101 Self::save_collection(target_collection);11021103 Ok(())1104 }11051106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1119 #[transactional]1120 pub fn set_offchain_schema(1121 origin,1122 collection_id: CollectionId,1123 schema: Vec<u8>1124 ) -> DispatchResult {1125 let sender = ensure_signed(origin)?;1126 let mut target_collection = Self::get_collection(collection_id)?;1127 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;11281129 1130 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11311132 target_collection.offchain_schema = schema;1133 Self::save_collection(target_collection);11341135 Ok(())1136 }11371138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1151 #[transactional]1152 pub fn set_const_on_chain_schema (1153 origin,1154 collection_id: CollectionId,1155 schema: Vec<u8>1156 ) -> DispatchResult {1157 let sender = ensure_signed(origin)?;1158 let mut target_collection = Self::get_collection(collection_id)?;1159 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;11601161 1162 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11631164 target_collection.const_on_chain_schema = schema;1165 Self::save_collection(target_collection);11661167 Ok(())1168 }11691170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1183 #[transactional]1184 pub fn set_variable_on_chain_schema (1185 origin,1186 collection_id: CollectionId,1187 schema: Vec<u8>1188 ) -> DispatchResult {1189 let sender = ensure_signed(origin)?;1190 let mut target_collection = Self::get_collection(collection_id)?;1191 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;11921193 1194 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");11951196 target_collection.variable_on_chain_schema = schema;1197 Self::save_collection(target_collection);11981199 Ok(())1200 }12011202 1203 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1204 #[transactional]1205 pub fn set_chain_limits(1206 origin,1207 limits: ChainLimits1208 ) -> DispatchResult {12091210 #[cfg(not(feature = "runtime-benchmarks"))]1211 ensure_root(origin)?;12121213 <ChainLimit>::put(limits);1214 Ok(())1215 }12161217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1229 #[transactional]1230 pub fn enable_contract_sponsoring(1231 origin,1232 contract_address: T::AccountId,1233 enable: bool1234 ) -> DispatchResult {12351236 let sender = ensure_signed(origin)?;12371238 #[cfg(feature = "runtime-benchmarks")]1239 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());12401241 Self::ensure_contract_owned(sender, &contract_address)?;12421243 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1244 Ok(())1245 }12461247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1265 #[transactional]1266 pub fn set_contract_sponsoring_rate_limit(1267 origin,1268 contract_address: T::AccountId,1269 rate_limit: T::BlockNumber1270 ) -> DispatchResult {1271 let sender = ensure_signed(origin)?;12721273 #[cfg(feature = "runtime-benchmarks")]1274 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());12751276 Self::ensure_contract_owned(sender, &contract_address)?;1277 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1278 Ok(())1279 }12801281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1293 #[transactional]1294 pub fn toggle_contract_white_list(1295 origin,1296 contract_address: T::AccountId,1297 enable: bool1298 ) -> DispatchResult {1299 let sender = ensure_signed(origin)?;13001301 #[cfg(feature = "runtime-benchmarks")]1302 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13031304 Self::ensure_contract_owned(sender, &contract_address)?;1305 if enable {1306 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1307 } else {1308 <ContractWhiteListEnabled<T>>::remove(contract_address);1309 }1310 Ok(())1311 }1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1325 #[transactional]1326 pub fn add_to_contract_white_list(1327 origin,1328 contract_address: T::AccountId,1329 account_address: T::AccountId1330 ) -> DispatchResult {1331 let sender = ensure_signed(origin)?;13321333 #[cfg(feature = "runtime-benchmarks")]1334 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1335 1336 Self::ensure_contract_owned(sender, &contract_address)?; 1337 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1338 Ok(())1339 }13401341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1353 #[transactional]1354 pub fn remove_from_contract_white_list(1355 origin,1356 contract_address: T::AccountId,1357 account_address: T::AccountId1358 ) -> DispatchResult {1359 let sender = ensure_signed(origin)?;13601361 #[cfg(feature = "runtime-benchmarks")]1362 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13631364 Self::ensure_contract_owned(sender, &contract_address)?;1365 <ContractWhiteList<T>>::remove(contract_address, account_address);1366 Ok(())1367 }13681369 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1370 #[transactional]1371 pub fn set_collection_limits(1372 origin,1373 collection_id: u32,1374 new_limits: CollectionLimits<T::BlockNumber>,1375 ) -> DispatchResult {1376 let sender = ensure_signed(origin)?;1377 let mut target_collection = Self::get_collection(collection_id)?;1378 Self::check_owner_permissions(&target_collection, sender.clone())?;1379 let old_limits = &target_collection.limits;1380 let chain_limits = ChainLimit::get();13811382 1383 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1384 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1385 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1386 Error::<T>::CollectionLimitBoundsExceeded);13871388 1389 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1390 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);13911392 ensure!(1393 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1394 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1395 Error::<T>::OwnerPermissionsCantBeReverted,1396 );13971398 target_collection.limits = new_limits;1399 Self::save_collection(target_collection);14001401 Ok(())1402 } 1403 }1404}14051406impl<T: Config> Module<T> {1407 pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1408 let target_collection = Self::get_collection(collection_id)?;14091410 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1411 Self::validate_create_item_args(&target_collection, &data)?;1412 Self::create_item_no_validation(&target_collection, owner, data)?;14131414 Ok(())1415 }14161417 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1418 1419 Self::is_correct_transfer(target_collection, &recipient)?;14201421 1422 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1423 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1424 Error::<T>::NoPermission);14251426 if target_collection.access == AccessMode::WhiteList {1427 Self::check_white_list(target_collection, &sender)?;1428 Self::check_white_list(target_collection, &recipient)?;1429 }14301431 match target_collection.mode1432 {1433 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1434 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1435 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1436 _ => ()1437 };14381439 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));14401441 Ok(())1442 }14431444 pub fn approve_internal(1445 sender: T::AccountId,1446 spender: T::AccountId,1447 collection: &CollectionHandle<T>,1448 item_id: TokenId,1449 amount: u128,1450 ) -> DispatchResult {1451 Self::token_exists(&collection, item_id)?;14521453 1454 let bypasses_limits = collection.limits.owner_can_transfer &&1455 Self::is_owner_or_admin_permissions(1456 &collection,1457 sender.clone(),1458 );14591460 let allowance_limit = if bypasses_limits {1461 None1462 } else if let Some(amount) = Self::owned_amount(1463 sender.clone(),1464 &collection,1465 item_id,1466 ) {1467 Some(amount)1468 } else {1469 fail!(Error::<T>::NoPermission);1470 };14711472 if collection.access == AccessMode::WhiteList {1473 Self::check_white_list(&collection, &sender)?;1474 Self::check_white_list(&collection, &spender)?;1475 }14761477 let allowance: u128 = amount1478 .checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1479 .ok_or(Error::<T>::NumOverflow)?;1480 if let Some(limit) = allowance_limit {1481 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1482 }1483 <Allowances<T>>::insert(collection.id, (item_id, &sender, &spender), allowance);14841485 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1486 Ok(())1487 }14881489 pub fn transfer_from_internal(1490 sender: T::AccountId,1491 from: T::AccountId,1492 recipient: T::AccountId,1493 collection: &CollectionHandle<T>,1494 item_id: TokenId,1495 amount: u128,1496 ) -> DispatchResult {1497 1498 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));14991500 1501 Self::is_correct_transfer(&collection, &recipient)?;15021503 1504 ensure!(1505 approval >= amount || 1506 (1507 collection.limits.owner_can_transfer &&1508 Self::is_owner_or_admin_permissions(&collection, sender.clone())1509 ),1510 Error::<T>::NoPermission1511 );15121513 if collection.access == AccessMode::WhiteList {1514 Self::check_white_list(&collection, &sender)?;1515 Self::check_white_list(&collection, &recipient)?;1516 }15171518 1519 let allowance = approval.saturating_sub(amount);1520 if allowance > 0 {1521 <Allowances<T>>::insert(collection.id, (item_id, &from, &sender), allowance);1522 } else {1523 <Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1524 }15251526 match collection.mode {1527 CollectionMode::NFT => {1528 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1529 }1530 CollectionMode::Fungible(_) => {1531 Self::transfer_fungible(&collection, amount, &from, &recipient)?1532 }1533 CollectionMode::ReFungible => {1534 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1535 }1536 _ => ()1537 };15381539 Ok(())1540 }15411542 pub fn set_variable_meta_data_internal(1543 sender: T::AccountId,1544 collection: &CollectionHandle<T>, 1545 item_id: TokenId,1546 data: Vec<u8>,1547 ) -> DispatchResult {1548 Self::token_exists(&collection, item_id)?;15491550 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);15511552 1553 ensure!(Self::is_item_owner(sender.clone(), &collection, item_id) ||1554 Self::is_owner_or_admin_permissions(&collection, sender.clone()),1555 Error::<T>::NoPermission);15561557 match collection.mode1558 {1559 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1560 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1561 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1562 _ => fail!(Error::<T>::UnexpectedCollectionType)1563 };15641565 Ok(())1566 }15671568 pub fn create_multiple_items_internal(1569 sender: T::AccountId,1570 collection: &CollectionHandle<T>,1571 owner: T::AccountId,1572 items_data: Vec<CreateItemData>,1573 ) -> DispatchResult {1574 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;15751576 for data in &items_data {1577 Self::validate_create_item_args(&collection, data)?;1578 }1579 for data in &items_data {1580 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1581 }15821583 Ok(())1584 }15851586 pub fn toggle_white_list_internal(1587 sender: &T::AccountId,1588 collection: &CollectionHandle<T>,1589 address: &T::AccountId,1590 whitelisted: bool,1591 ) -> DispatchResult {1592 Self::check_owner_or_admin_permissions(&collection, sender.clone())?;15931594 if whitelisted {1595 <WhiteList<T>>::insert(collection.id, address, true);1596 } else {1597 <WhiteList<T>>::remove(collection.id, address);1598 }15991600 Ok(())1601 }16021603 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1604 let collection_id = collection.id;16051606 1607 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1608 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1609 1610 Ok(())1611 }16121613 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1614 let collection_id = collection.id;16151616 1617 let total_items: u32 = ItemListIndex::get(collection_id)1618 .checked_add(amount)1619 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1620 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1621 .checked_add(amount)1622 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1623 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1624 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);16251626 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1627 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1628 Self::check_white_list(collection, owner)?;1629 Self::check_white_list(collection, sender)?;1630 }16311632 Ok(())1633 }16341635 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1636 match target_collection.mode1637 {1638 CollectionMode::NFT => {1639 if let CreateItemData::NFT(data) = data {1640 1641 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1642 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1643 } else {1644 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1645 }1646 },1647 CollectionMode::Fungible(_) => {1648 if let CreateItemData::Fungible(_) = data {1649 } else {1650 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1651 }1652 },1653 CollectionMode::ReFungible => {1654 if let CreateItemData::ReFungible(data) = data {16551656 1657 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1658 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16591660 1661 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1662 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1663 } else {1664 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1665 }1666 },1667 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1668 };16691670 Ok(())1671 }16721673 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1674 match data1675 {1676 CreateItemData::NFT(data) => {1677 let item = NftItemType {1678 owner: owner.clone(),1679 const_data: data.const_data,1680 variable_data: data.variable_data1681 };16821683 Self::add_nft_item(collection, item)?;1684 },1685 CreateItemData::Fungible(data) => {1686 Self::add_fungible_item(collection, &owner, data.value)?;1687 },1688 CreateItemData::ReFungible(data) => {1689 let mut owner_list = Vec::new();1690 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});16911692 let item = ReFungibleItemType {1693 owner: owner_list,1694 const_data: data.const_data,1695 variable_data: data.variable_data1696 };16971698 Self::add_refungible_item(collection, item)?;1699 }1700 };17011702 Ok(())1703 }17041705 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1706 let collection_id = collection.id;17071708 1709 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;17101711 1712 let item = FungibleItemType {1713 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1714 };1715 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);17161717 1718 let new_balance = <Balance<T>>::get(collection_id, owner)1719 .checked_add(value)1720 .ok_or(Error::<T>::NumOverflow)?;1721 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);17221723 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1724 Ok(())1725 }17261727 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1728 let collection_id = collection.id;17291730 let current_index = <ItemListIndex>::get(collection_id)1731 .checked_add(1)1732 .ok_or(Error::<T>::NumOverflow)?;1733 let itemcopy = item.clone();17341735 ensure!(1736 item.owner.len() == 1,1737 Error::<T>::BadCreateRefungibleCall,1738 );1739 let item_owner = item.owner.first().expect("only one owner is defined");17401741 let value = item_owner.fraction;1742 let owner = item_owner.owner.clone();17431744 Self::add_token_index(collection_id, current_index, &owner)?;17451746 <ItemListIndex>::insert(collection_id, current_index);1747 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17481749 1750 let new_balance = <Balance<T>>::get(collection_id, &owner)1751 .checked_add(value)1752 .ok_or(Error::<T>::NumOverflow)?;1753 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17541755 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1756 Ok(())1757 }17581759 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1760 let collection_id = collection.id;17611762 let current_index = <ItemListIndex>::get(collection_id)1763 .checked_add(1)1764 .ok_or(Error::<T>::NumOverflow)?;17651766 let item_owner = item.owner.clone();1767 Self::add_token_index(collection_id, current_index, &item.owner)?;17681769 <ItemListIndex>::insert(collection_id, current_index);1770 <NftItemList<T>>::insert(collection_id, current_index, item);17711772 1773 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1774 .checked_add(1)1775 .ok_or(Error::<T>::NumOverflow)?;1776 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17771778 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1779 Ok(())1780 }17811782 fn burn_refungible_item(1783 collection: &CollectionHandle<T>,1784 item_id: TokenId,1785 owner: &T::AccountId,1786 ) -> DispatchResult {1787 let collection_id = collection.id;17881789 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1790 .ok_or(Error::<T>::TokenNotFound)?;1791 let rft_balance = token1792 .owner1793 .iter()1794 .find(|&i| i.owner == *owner)1795 .ok_or(Error::<T>::TokenNotFound)?;1796 Self::remove_token_index(collection_id, item_id, owner)?;17971798 1799 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1800 .checked_sub(rft_balance.fraction)1801 .ok_or(Error::<T>::NumOverflow)?;1802 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);18031804 1805 let index = token1806 .owner1807 .iter()1808 .position(|i| i.owner == *owner)1809 .expect("owned item is exists");1810 token.owner.remove(index);1811 let owner_count = token.owner.len();18121813 1814 if owner_count == 0 {1815 <ReFungibleItemList<T>>::remove(collection_id, item_id);1816 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1817 }1818 else {1819 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1820 }18211822 Ok(())1823 }18241825 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1826 let collection_id = collection.id;18271828 let item = <NftItemList<T>>::get(collection_id, item_id)1829 .ok_or(Error::<T>::TokenNotFound)?;1830 Self::remove_token_index(collection_id, item_id, &item.owner)?;18311832 1833 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1834 .checked_sub(1)1835 .ok_or(Error::<T>::NumOverflow)?;1836 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1837 <NftItemList<T>>::remove(collection_id, item_id);1838 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18391840 Ok(())1841 }18421843 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {1844 let collection_id = collection.id;18451846 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1847 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18481849 1850 let new_balance = <Balance<T>>::get(collection_id, owner)1851 .checked_sub(value)1852 .ok_or(Error::<T>::NumOverflow)?;1853 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18541855 if balance.value - value > 0 {1856 balance.value -= value;1857 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1858 }1859 else {1860 <FungibleItemList<T>>::remove(collection_id, owner);1861 }18621863 Ok(())1864 }18651866 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1867 Ok(<CollectionById<T>>::get(collection_id)1868 .map(|collection| CollectionHandle {1869 id: collection_id,1870 collection1871 })1872 .ok_or(Error::<T>::CollectionNotFound)?)1873 }18741875 fn save_collection(collection: CollectionHandle<T>) {1876 <CollectionById<T>>::insert(collection.id, collection.collection);1877 }18781879 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {1880 ensure!(1881 subject == target_collection.owner,1882 Error::<T>::NoPermission1883 );18841885 Ok(())1886 }18871888 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {1889 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)1890 }18911892 fn check_owner_or_admin_permissions(1893 collection: &CollectionHandle<T>,1894 subject: T::AccountId,1895 ) -> DispatchResult {1896 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);18971898 Ok(())1899 }19001901 fn owned_amount(1902 subject: T::AccountId,1903 target_collection: &CollectionHandle<T>,1904 item_id: TokenId,1905 ) -> Option<u128> {1906 let collection_id = target_collection.id;19071908 match target_collection.mode {1909 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)1910 .then(|| 1),1911 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)1912 .value),1913 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1914 .owner1915 .iter()1916 .find(|i| i.owner == subject)1917 .map(|i| i.fraction),1918 CollectionMode::Invalid => None,1919 }1920 }19211922 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {1923 match target_collection.mode {1924 CollectionMode::Fungible(_) => true,1925 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),1926 }1927 }19281929 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {1930 let collection_id = collection.id;19311932 let mes = Error::<T>::AddresNotInWhiteList;1933 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19341935 Ok(())1936 }19371938 1939 1940 fn token_exists(1941 target_collection: &CollectionHandle<T>,1942 item_id: TokenId,1943 ) -> DispatchResult {1944 let collection_id = target_collection.id;1945 let exists = match target_collection.mode1946 {1947 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1948 CollectionMode::Fungible(_) => true,1949 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1950 _ => false1951 };19521953 ensure!(exists == true, Error::<T>::TokenNotFound);1954 Ok(())1955 }19561957 fn transfer_fungible(1958 collection: &CollectionHandle<T>,1959 value: u128,1960 owner: &T::AccountId,1961 recipient: &T::AccountId,1962 ) -> DispatchResult {1963 let collection_id = collection.id;19641965 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1966 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19671968 1969 Self::add_fungible_item(collection, recipient, value)?;19701971 1972 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);19731974 1975 if balance.value == value {1976 <FungibleItemList<T>>::remove(collection_id, owner);1977 }1978 else {1979 balance.value -= value;1980 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1981 }19821983 Ok(())1984 }19851986 fn transfer_refungible(1987 collection: &CollectionHandle<T>,1988 item_id: TokenId,1989 value: u128,1990 owner: T::AccountId,1991 new_owner: T::AccountId,1992 ) -> DispatchResult {1993 let collection_id = collection.id;1994 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)1995 .ok_or(Error::<T>::TokenNotFound)?;19961997 let item = full_item1998 .owner1999 .iter()2000 .filter(|i| i.owner == owner)2001 .next()2002 .ok_or(Error::<T>::TokenNotFound)?;2003 let amount = item.fraction;20042005 ensure!(amount >= value, Error::<T>::TokenValueTooLow);20062007 2008 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2009 .checked_sub(value)2010 .ok_or(Error::<T>::NumOverflow)?;2011 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20122013 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2014 .checked_add(value)2015 .ok_or(Error::<T>::NumOverflow)?;2016 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);20172018 let old_owner = item.owner.clone();2019 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20202021 2022 if amount == value && !new_owner_has_account {2023 2024 2025 let mut new_full_item = full_item.clone();2026 new_full_item2027 .owner2028 .iter_mut()2029 .find(|i| i.owner == owner)2030 .expect("old owner does present in refungible")2031 .owner = new_owner.clone();2032 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20332034 2035 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2036 } else {2037 let mut new_full_item = full_item.clone();2038 new_full_item2039 .owner2040 .iter_mut()2041 .find(|i| i.owner == owner)2042 .expect("old owner does present in refungible")2043 .fraction -= value;20442045 2046 if new_owner_has_account {2047 2048 new_full_item2049 .owner2050 .iter_mut()2051 .find(|i| i.owner == new_owner)2052 .expect("new owner has account")2053 .fraction += value;2054 } else {2055 2056 new_full_item.owner.push(Ownership {2057 owner: new_owner.clone(),2058 fraction: value,2059 });2060 Self::add_token_index(collection_id, item_id, &new_owner)?;2061 }20622063 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2064 }20652066 Ok(())2067 }20682069 fn transfer_nft(2070 collection: &CollectionHandle<T>,2071 item_id: TokenId,2072 sender: T::AccountId,2073 new_owner: T::AccountId,2074 ) -> DispatchResult {2075 let collection_id = collection.id;2076 let mut item = <NftItemList<T>>::get(collection_id, item_id)2077 .ok_or(Error::<T>::TokenNotFound)?;20782079 ensure!(2080 sender == item.owner,2081 Error::<T>::MustBeTokenOwner2082 );20832084 2085 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2086 .checked_sub(1)2087 .ok_or(Error::<T>::NumOverflow)?;2088 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20892090 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2091 .checked_add(1)2092 .ok_or(Error::<T>::NumOverflow)?;2093 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20942095 2096 let old_owner = item.owner.clone();2097 item.owner = new_owner.clone();2098 <NftItemList<T>>::insert(collection_id, item_id, item);20992100 2101 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21022103 Ok(())2104 }2105 2106 fn set_re_fungible_variable_data(2107 collection: &CollectionHandle<T>,2108 item_id: TokenId,2109 data: Vec<u8>2110 ) -> DispatchResult {2111 let collection_id = collection.id;2112 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2113 .ok_or(Error::<T>::TokenNotFound)?;21142115 item.variable_data = data;21162117 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21182119 Ok(())2120 }21212122 fn set_nft_variable_data(2123 collection: &CollectionHandle<T>,2124 item_id: TokenId,2125 data: Vec<u8>2126 ) -> DispatchResult {2127 let collection_id = collection.id;2128 let mut item = <NftItemList<T>>::get(collection_id, item_id)2129 .ok_or(Error::<T>::TokenNotFound)?;2130 2131 item.variable_data = data;21322133 <NftItemList<T>>::insert(collection_id, item_id, item);2134 2135 Ok(())2136 }21372138 #[allow(dead_code)]2139 fn init_collection(item: &Collection<T>) {2140 2141 assert!(2142 item.decimal_points <= MAX_DECIMAL_POINTS,2143 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2144 );2145 assert!(2146 item.name.len() <= 64,2147 "Collection name can not be longer than 63 char"2148 );2149 assert!(2150 item.name.len() <= 256,2151 "Collection description can not be longer than 255 char"2152 );2153 assert!(2154 item.token_prefix.len() <= 16,2155 "Token prefix can not be longer than 15 char"2156 );21572158 2159 let next_id = CreatedCollectionCount::get()2160 .checked_add(1)2161 .unwrap();21622163 CreatedCollectionCount::put(next_id);2164 }21652166 #[allow(dead_code)]2167 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2168 let current_index = <ItemListIndex>::get(collection_id)2169 .checked_add(1)2170 .unwrap();21712172 let item_owner = item.owner.clone();2173 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();21742175 <ItemListIndex>::insert(collection_id, current_index);21762177 2178 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2179 .checked_add(1)2180 .unwrap();2181 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2182 }21832184 #[allow(dead_code)]2185 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2186 let current_index = <ItemListIndex>::get(collection_id)2187 .checked_add(1)2188 .unwrap();21892190 Self::add_token_index(collection_id, current_index, owner).unwrap();21912192 <ItemListIndex>::insert(collection_id, current_index);21932194 2195 let new_balance = <Balance<T>>::get(collection_id, owner)2196 .checked_add(item.value)2197 .unwrap();2198 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2199 }22002201 #[allow(dead_code)]2202 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2203 let current_index = <ItemListIndex>::get(collection_id)2204 .checked_add(1)2205 .unwrap();22062207 let value = item.owner.first().unwrap().fraction;2208 let owner = item.owner.first().unwrap().owner.clone();22092210 Self::add_token_index(collection_id, current_index, &owner).unwrap();22112212 <ItemListIndex>::insert(collection_id, current_index);22132214 2215 let new_balance = <Balance<T>>::get(collection_id, &owner)2216 .checked_add(value)2217 .unwrap();2218 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2219 }22202221 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2222 2223 if <AccountItemCount<T>>::contains_key(owner) {22242225 2226 let count = <AccountItemCount<T>>::get(owner);2227 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);22282229 <AccountItemCount<T>>::insert(owner.clone(), count2230 .checked_add(1)2231 .ok_or(Error::<T>::NumOverflow)?);2232 }2233 else {2234 <AccountItemCount<T>>::insert(owner.clone(), 1);2235 }22362237 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2238 if list_exists {2239 let mut list = <AddressTokens<T>>::get(collection_id, owner);2240 let item_contains = list.contains(&item_index.clone());22412242 if !item_contains {2243 list.push(item_index.clone());2244 }22452246 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2247 } else {2248 let mut itm = Vec::new();2249 itm.push(item_index.clone());2250 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2251 }22522253 Ok(())2254 }22552256 fn remove_token_index(2257 collection_id: CollectionId,2258 item_index: TokenId,2259 owner: &T::AccountId,2260 ) -> DispatchResult {22612262 2263 <AccountItemCount<T>>::insert(owner.clone(), 2264 <AccountItemCount<T>>::get(owner)2265 .checked_sub(1)2266 .ok_or(Error::<T>::NumOverflow)?);226722682269 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2270 if list_exists {2271 let mut list = <AddressTokens<T>>::get(collection_id, owner);2272 let item_contains = list.contains(&item_index.clone());22732274 if item_contains {2275 list.retain(|&item| item != item_index);2276 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2277 }2278 }22792280 Ok(())2281 }22822283 fn move_token_index(2284 collection_id: CollectionId,2285 item_index: TokenId,2286 old_owner: &T::AccountId,2287 new_owner: &T::AccountId,2288 ) -> DispatchResult {2289 Self::remove_token_index(collection_id, item_index, old_owner)?;2290 Self::add_token_index(collection_id, item_index, new_owner)?;22912292 Ok(())2293 }2294 2295 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2296 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);22972298 Ok(())2299 }2300}