123456#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 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 {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, item_owner: T::CrossAccountId, 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, &item_owner, 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 item_owner: &T::CrossAccountId,1600 value: u128,1601 ) -> DispatchResult {1602 ensure!(1603 Self::is_item_owner(sender, collection, item_id)?1604 || (collection.limits.owner_can_transfer1605 && Self::is_owner_or_admin_permissions(collection, sender)?),1606 Error::<T>::NoPermission1607 );16081609 if collection.access == AccessMode::WhiteList {1610 Self::check_white_list(collection, sender)?;1611 }16121613 match collection.mode {1614 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1615 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, item_owner, value)?,1616 CollectionMode::ReFungible => {1617 Self::burn_refungible_item(collection, item_id, item_owner)?1618 }1619 _ => (),1620 };16211622 Ok(())1623 }16241625 pub fn toggle_white_list_internal(1626 sender: &T::CrossAccountId,1627 collection: &CollectionHandle<T>,1628 address: &T::CrossAccountId,1629 whitelisted: bool,1630 ) -> DispatchResult {1631 Self::check_owner_or_admin_permissions(collection, sender)?;16321633 if whitelisted {1634 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1635 } else {1636 <WhiteList<T>>::remove(collection.id, address.as_sub());1637 }16381639 Ok(())1640 }16411642 fn is_correct_transfer(1643 collection: &CollectionHandle<T>,1644 recipient: &T::CrossAccountId,1645 ) -> DispatchResult {1646 let collection_id = collection.id;16471648 1649 collection.consume_sload()?;1650 let account_items: u32 =1651 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16521653 1654 1655 let limit = if collection.limits.account_token_ownership_limit == 01656 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1657 {1658 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1659 } else {1660 collection.limits.account_token_ownership_limit1661 };16621663 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16641665 1666 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16671668 Ok(())1669 }16701671 fn can_create_items_in_collection(1672 collection: &CollectionHandle<T>,1673 sender: &T::CrossAccountId,1674 owner: &T::CrossAccountId,1675 amount: u32,1676 ) -> DispatchResult {1677 let collection_id = collection.id;16781679 1680 let total_items: u32 = ItemListIndex::get(collection_id)1681 .checked_add(amount)1682 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1683 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1684 as u32)1685 .checked_add(amount)1686 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16871688 1689 1690 let account_token_limit = if collection.limits.account_token_ownership_limit == 01691 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1692 {1693 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1694 } else {1695 collection.limits.account_token_ownership_limit1696 };16971698 ensure!(1699 collection.limits.token_limit >= total_items,1700 Error::<T>::CollectionTokenLimitExceeded1701 );1702 ensure!(1703 account_token_limit >= account_items,1704 Error::<T>::AccountTokenLimitExceeded1705 );17061707 if !Self::is_owner_or_admin_permissions(collection, sender)? {1708 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1709 Self::check_white_list(collection, owner)?;1710 Self::check_white_list(collection, sender)?;1711 }17121713 Ok(())1714 }17151716 fn validate_create_item_args(1717 target_collection: &CollectionHandle<T>,1718 data: &CreateItemData,1719 ) -> DispatchResult {1720 match target_collection.mode {1721 CollectionMode::NFT => {1722 if !matches!(data, CreateItemData::NFT(_)) {1723 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1724 }1725 }1726 CollectionMode::Fungible(_) => {1727 if !matches!(data, CreateItemData::Fungible(_)) {1728 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1729 }1730 }1731 CollectionMode::ReFungible => {1732 if let CreateItemData::ReFungible(data) = data {1733 1734 ensure!(1735 data.pieces <= MAX_REFUNGIBLE_PIECES,1736 Error::<T>::WrongRefungiblePieces1737 );1738 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1739 } else {1740 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1741 }1742 }1743 };17441745 Ok(())1746 }17471748 fn create_item_no_validation(1749 collection: &CollectionHandle<T>,1750 owner: &T::CrossAccountId,1751 data: CreateItemData,1752 ) -> DispatchResult {1753 match data {1754 CreateItemData::NFT(data) => {1755 let item = NftItemType {1756 owner: owner.clone(),1757 const_data: data.const_data.into_inner(),1758 variable_data: data.variable_data.into_inner(),1759 };17601761 Self::add_nft_item(collection, item)?;1762 }1763 CreateItemData::Fungible(data) => {1764 Self::add_fungible_item(collection, owner, data.value)?;1765 }1766 CreateItemData::ReFungible(data) => {1767 let owner_list = vec![Ownership {1768 owner: owner.clone(),1769 fraction: data.pieces,1770 }];17711772 let item = ReFungibleItemType {1773 owner: owner_list,1774 const_data: data.const_data.into_inner(),1775 variable_data: data.variable_data.into_inner(),1776 };17771778 Self::add_refungible_item(collection, item)?;1779 }1780 };17811782 Ok(())1783 }17841785 fn add_fungible_item(1786 collection: &CollectionHandle<T>,1787 owner: &T::CrossAccountId,1788 value: u128,1789 ) -> DispatchResult {1790 let collection_id = collection.id;17911792 1793 collection.consume_sload()?;1794 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17951796 1797 let item = FungibleItemType {1798 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1799 };1800 collection.consume_sstore()?;1801 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18021803 1804 collection.consume_sload()?;1805 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1806 .checked_add(value)1807 .ok_or(Error::<T>::NumOverflow)?;1808 collection.consume_sstore()?;1809 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18101811 collection.log(ERC20Events::Transfer {1812 from: H160::default(),1813 to: *owner.as_eth(),1814 value: value.into(),1815 })?;1816 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1817 Ok(())1818 }18191820 fn add_refungible_item(1821 collection: &CollectionHandle<T>,1822 item: ReFungibleItemType<T::CrossAccountId>,1823 ) -> DispatchResult {1824 let collection_id = collection.id;18251826 let current_index = <ItemListIndex>::get(collection_id)1827 .checked_add(1)1828 .ok_or(Error::<T>::NumOverflow)?;1829 let itemcopy = item.clone();18301831 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1832 let item_owner = item.owner.first().expect("only one owner is defined");18331834 let value = item_owner.fraction;1835 let owner = item_owner.owner.clone();18361837 Self::add_token_index(collection, current_index, &owner)?;18381839 <ItemListIndex>::insert(collection_id, current_index);1840 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18411842 1843 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1844 .checked_add(value)1845 .ok_or(Error::<T>::NumOverflow)?;1846 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18471848 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1849 Ok(())1850 }18511852 fn add_nft_item(1853 collection: &CollectionHandle<T>,1854 item: NftItemType<T::CrossAccountId>,1855 ) -> DispatchResult {1856 let collection_id = collection.id;18571858 let current_index = <ItemListIndex>::get(collection_id)1859 .checked_add(1)1860 .ok_or(Error::<T>::NumOverflow)?;18611862 let item_owner = item.owner.clone();1863 Self::add_token_index(collection, current_index, &item.owner)?;18641865 <ItemListIndex>::insert(collection_id, current_index);1866 <NftItemList<T>>::insert(collection_id, current_index, item);18671868 1869 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1870 .checked_add(1)1871 .ok_or(Error::<T>::NumOverflow)?;1872 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18731874 collection.log(ERC721Events::Transfer {1875 from: H160::default(),1876 to: *item_owner.as_eth(),1877 token_id: current_index.into(),1878 })?;1879 Self::deposit_event(RawEvent::ItemCreated(1880 collection_id,1881 current_index,1882 item_owner,1883 ));1884 Ok(())1885 }18861887 fn burn_refungible_item(1888 collection: &CollectionHandle<T>,1889 item_id: TokenId,1890 owner: &T::CrossAccountId,1891 ) -> DispatchResult {1892 let collection_id = collection.id;18931894 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1895 .ok_or(Error::<T>::TokenNotFound)?;1896 let rft_balance = token1897 .owner1898 .iter()1899 .find(|&i| i.owner == *owner)1900 .ok_or(Error::<T>::TokenNotFound)?;1901 Self::remove_token_index(collection, item_id, owner)?;19021903 1904 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1905 .checked_sub(rft_balance.fraction)1906 .ok_or(Error::<T>::NumOverflow)?;1907 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19081909 1910 let index = token1911 .owner1912 .iter()1913 .position(|i| i.owner == *owner)1914 .expect("owned item is exists");1915 token.owner.remove(index);1916 let owner_count = token.owner.len();19171918 1919 if owner_count == 0 {1920 <ReFungibleItemList<T>>::remove(collection_id, item_id);1921 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1922 } else {1923 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1924 }19251926 Ok(())1927 }19281929 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1930 let collection_id = collection.id;19311932 let item =1933 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1934 Self::remove_token_index(collection, item_id, &item.owner)?;19351936 1937 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1938 .checked_sub(1)1939 .ok_or(Error::<T>::NumOverflow)?;1940 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1941 <NftItemList<T>>::remove(collection_id, item_id);1942 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19431944 collection.log(ERC721Events::Transfer {1945 from: *item.owner.as_eth(),1946 to: H160::default(),1947 token_id: item_id.into(),1948 })?;1949 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1950 Ok(())1951 }19521953 fn burn_fungible_item(1954 collection: &CollectionHandle<T>,1955 owner: &T::CrossAccountId,1956 value: u128,1957 ) -> DispatchResult {1958 let collection_id = collection.id;19591960 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1961 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19621963 1964 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1965 .checked_sub(value)1966 .ok_or(Error::<T>::NumOverflow)?;1967 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19681969 if balance.value - value > 0 {1970 balance.value -= value;1971 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1972 } else {1973 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1974 }19751976 collection.log(ERC20Events::Transfer {1977 from: *owner.as_eth(),1978 to: H160::default(),1979 value: value.into(),1980 })?;1981 Ok(())1982 }19831984 pub fn get_collection(1985 collection_id: CollectionId,1986 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1987 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1988 }19891990 fn check_owner_permissions(1991 target_collection: &CollectionHandle<T>,1992 subject: &T::AccountId,1993 ) -> DispatchResult {1994 ensure!(1995 *subject == target_collection.owner,1996 Error::<T>::NoPermission1997 );19981999 Ok(())2000 }20012002 fn is_owner_or_admin_permissions(2003 collection: &CollectionHandle<T>,2004 subject: &T::CrossAccountId,2005 ) -> Result<bool, DispatchError> {2006 collection.consume_sload()?;2007 Ok(*subject.as_sub() == collection.owner2008 || <AdminList<T>>::get(collection.id).contains(subject))2009 }20102011 fn check_owner_or_admin_permissions(2012 collection: &CollectionHandle<T>,2013 subject: &T::CrossAccountId,2014 ) -> DispatchResult {2015 ensure!(2016 Self::is_owner_or_admin_permissions(collection, subject)?,2017 Error::<T>::NoPermission2018 );20192020 Ok(())2021 }20222023 fn owned_amount(2024 subject: &T::CrossAccountId,2025 collection: &CollectionHandle<T>,2026 item_id: TokenId,2027 ) -> Result<Option<u128>, DispatchError> {2028 collection.consume_sload()?;2029 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2030 }20312032 fn owned_amount_unchecked(2033 subject: &T::CrossAccountId,2034 target_collection: &CollectionHandle<T>,2035 item_id: TokenId,2036 ) -> Option<u128> {2037 let collection_id = target_collection.id;20382039 match target_collection.mode {2040 CollectionMode::NFT => {2041 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2042 }2043 CollectionMode::Fungible(_) => {2044 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2045 }2046 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2047 .owner2048 .iter()2049 .find(|i| i.owner == *subject)2050 .map(|i| i.fraction),2051 }2052 }20532054 fn is_item_owner(2055 subject: &T::CrossAccountId,2056 target_collection: &CollectionHandle<T>,2057 item_id: TokenId,2058 ) -> Result<bool, DispatchError> {2059 Ok(match target_collection.mode {2060 CollectionMode::Fungible(_) => true,2061 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2062 })2063 }20642065 fn check_white_list(2066 collection: &CollectionHandle<T>,2067 address: &T::CrossAccountId,2068 ) -> DispatchResult {2069 collection.consume_sload()?;2070 ensure!(2071 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2072 Error::<T>::AddresNotInWhiteList,2073 );2074 Ok(())2075 }20762077 2078 2079 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2080 let collection_id = target_collection.id;2081 let exists = match target_collection.mode {2082 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2083 CollectionMode::Fungible(_) => true,2084 CollectionMode::ReFungible => {2085 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2086 }2087 };20882089 ensure!(exists, Error::<T>::TokenNotFound);2090 Ok(())2091 }20922093 fn transfer_fungible(2094 collection: &CollectionHandle<T>,2095 value: u128,2096 owner: &T::CrossAccountId,2097 recipient: &T::CrossAccountId,2098 ) -> DispatchResult {2099 let collection_id = collection.id;21002101 collection.consume_sload()?;2102 collection.consume_sload()?;2103 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2104 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21052106 recipient_balance.value = recipient_balance2107 .value2108 .checked_add(value)2109 .ok_or(Error::<T>::NumOverflow)?;2110 balance.value = balance2111 .value2112 .checked_sub(value)2113 .ok_or(Error::<T>::TokenValueTooLow)?;21142115 2116 collection.consume_sstore()?;2117 collection.consume_sstore()?;2118 if balance.value != 0 {2119 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2120 } else {2121 <Balance<T>>::remove(collection_id, owner.as_sub());2122 }2123 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21242125 2126 collection.consume_sstore()?;2127 collection.consume_sstore()?;2128 if balance.value != 0 {2129 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2130 } else {2131 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2132 }2133 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21342135 collection.log(ERC20Events::Transfer {2136 from: *owner.as_eth(),2137 to: *recipient.as_eth(),2138 value: value.into(),2139 })?;2140 Self::deposit_event(RawEvent::Transfer(2141 collection.id,2142 1,2143 owner.clone(),2144 recipient.clone(),2145 value,2146 ));21472148 Ok(())2149 }21502151 fn transfer_refungible(2152 collection: &CollectionHandle<T>,2153 item_id: TokenId,2154 value: u128,2155 owner: T::CrossAccountId,2156 new_owner: T::CrossAccountId,2157 ) -> DispatchResult {2158 let collection_id = collection.id;2159 collection.consume_sload()?;2160 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2161 .ok_or(Error::<T>::TokenNotFound)?;21622163 let item = full_item2164 .owner2165 .iter()2166 .find(|i| i.owner == owner)2167 .ok_or(Error::<T>::TokenNotFound)?;2168 let amount = item.fraction;21692170 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21712172 collection.consume_sload()?;2173 2174 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2175 .checked_sub(value)2176 .ok_or(Error::<T>::NumOverflow)?;2177 collection.consume_sstore()?;2178 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21792180 collection.consume_sload()?;2181 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2182 .checked_add(value)2183 .ok_or(Error::<T>::NumOverflow)?;2184 collection.consume_sstore()?;2185 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21862187 let old_owner = item.owner.clone();2188 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21892190 let mut new_full_item = full_item.clone();2191 2192 if amount == value && !new_owner_has_account {2193 2194 2195 new_full_item2196 .owner2197 .iter_mut()2198 .find(|i| i.owner == owner)2199 .expect("old owner does present in refungible")2200 .owner = new_owner.clone();2201 collection.consume_sstore()?;2202 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22032204 2205 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2206 } else {2207 new_full_item2208 .owner2209 .iter_mut()2210 .find(|i| i.owner == owner)2211 .expect("old owner does present in refungible")2212 .fraction -= value;22132214 2215 if new_owner_has_account {2216 2217 new_full_item2218 .owner2219 .iter_mut()2220 .find(|i| i.owner == new_owner)2221 .expect("new owner has account")2222 .fraction += value;2223 } else {2224 2225 new_full_item.owner.push(Ownership {2226 owner: new_owner.clone(),2227 fraction: value,2228 });2229 Self::add_token_index(collection, item_id, &new_owner)?;2230 }22312232 collection.consume_sstore()?;2233 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2234 }22352236 Self::deposit_event(RawEvent::Transfer(2237 collection.id,2238 item_id,2239 owner,2240 new_owner,2241 amount,2242 ));22432244 Ok(())2245 }22462247 fn transfer_nft(2248 collection: &CollectionHandle<T>,2249 item_id: TokenId,2250 sender: T::CrossAccountId,2251 new_owner: T::CrossAccountId,2252 ) -> DispatchResult {2253 let collection_id = collection.id;2254 collection.consume_sload()?;2255 let mut item =2256 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22572258 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22592260 collection.consume_sload()?;2261 2262 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2263 .checked_sub(1)2264 .ok_or(Error::<T>::NumOverflow)?;2265 collection.consume_sstore()?;2266 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22672268 collection.consume_sload()?;2269 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2270 .checked_add(1)2271 .ok_or(Error::<T>::NumOverflow)?;2272 collection.consume_sstore()?;2273 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22742275 2276 let old_owner = item.owner.clone();2277 item.owner = new_owner.clone();2278 collection.consume_sstore()?;2279 <NftItemList<T>>::insert(collection_id, item_id, item);22802281 2282 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22832284 collection.log(ERC721Events::Transfer {2285 from: *sender.as_eth(),2286 to: *new_owner.as_eth(),2287 token_id: item_id.into(),2288 })?;2289 Self::deposit_event(RawEvent::Transfer(2290 collection.id,2291 item_id,2292 sender,2293 new_owner,2294 1,2295 ));22962297 Ok(())2298 }22992300 fn set_re_fungible_variable_data(2301 collection: &CollectionHandle<T>,2302 item_id: TokenId,2303 data: Vec<u8>,2304 ) -> DispatchResult {2305 let collection_id = collection.id;2306 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2307 .ok_or(Error::<T>::TokenNotFound)?;23082309 item.variable_data = data;23102311 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23122313 Ok(())2314 }23152316 fn set_nft_variable_data(2317 collection: &CollectionHandle<T>,2318 item_id: TokenId,2319 data: Vec<u8>,2320 ) -> DispatchResult {2321 let collection_id = collection.id;2322 let mut item =2323 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23242325 item.variable_data = data;23262327 <NftItemList<T>>::insert(collection_id, item_id, item);23282329 Ok(())2330 }23312332 #[allow(dead_code)]2333 fn init_collection(item: &Collection<T>) {2334 2335 assert!(2336 item.decimal_points <= MAX_DECIMAL_POINTS,2337 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2338 );2339 assert!(2340 item.name.len() <= 64,2341 "Collection name can not be longer than 63 char"2342 );2343 assert!(2344 item.name.len() <= 256,2345 "Collection description can not be longer than 255 char"2346 );2347 assert!(2348 item.token_prefix.len() <= 16,2349 "Token prefix can not be longer than 15 char"2350 );23512352 2353 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23542355 CreatedCollectionCount::put(next_id);2356 }23572358 #[allow(dead_code)]2359 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2360 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23612362 Self::add_token_index(2363 &CollectionHandle::get(collection_id).unwrap(),2364 current_index,2365 &item.owner,2366 )2367 .unwrap();23682369 <ItemListIndex>::insert(collection_id, current_index);23702371 2372 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2373 .checked_add(1)2374 .unwrap();2375 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2376 }23772378 #[allow(dead_code)]2379 fn init_fungible_token(2380 collection_id: CollectionId,2381 owner: &T::CrossAccountId,2382 item: &FungibleItemType,2383 ) {2384 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23852386 Self::add_token_index(2387 &CollectionHandle::get(collection_id).unwrap(),2388 current_index,2389 owner,2390 )2391 .unwrap();23922393 <ItemListIndex>::insert(collection_id, current_index);23942395 2396 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2397 .checked_add(item.value)2398 .unwrap();2399 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2400 }24012402 #[allow(dead_code)]2403 fn init_refungible_token(2404 collection_id: CollectionId,2405 item: &ReFungibleItemType<T::CrossAccountId>,2406 ) {2407 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24082409 let value = item.owner.first().unwrap().fraction;2410 let owner = item.owner.first().unwrap().owner.clone();24112412 Self::add_token_index(2413 &CollectionHandle::get(collection_id).unwrap(),2414 current_index,2415 &owner,2416 )2417 .unwrap();24182419 <ItemListIndex>::insert(collection_id, current_index);24202421 2422 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2423 .checked_add(value)2424 .unwrap();2425 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2426 }24272428 fn add_token_index(2429 collection: &CollectionHandle<T>,2430 item_index: TokenId,2431 owner: &T::CrossAccountId,2432 ) -> DispatchResult {2433 collection.consume_sload()?;2434 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2435 if list_exists {2436 collection.consume_sload()?;2437 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24382439 2440 let account_items: u32 = list.len() as u32;2441 ensure!(2442 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2443 Error::<T>::AddressOwnershipLimitExceeded2444 );24452446 let item_contains = list.contains(&item_index.clone());24472448 if !item_contains {2449 list.push(item_index);2450 }24512452 collection.consume_sstore()?;2453 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2454 } else {2455 let itm = vec![item_index];2456 collection.consume_sstore()?;2457 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2458 }24592460 Ok(())2461 }24622463 fn remove_token_index(2464 collection: &CollectionHandle<T>,2465 item_index: TokenId,2466 owner: &T::CrossAccountId,2467 ) -> DispatchResult {2468 collection.consume_sload()?;2469 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2470 if list_exists {2471 collection.consume_sload()?;2472 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2473 let item_contains = list.contains(&item_index.clone());24742475 if item_contains {2476 list.retain(|&item| item != item_index);2477 collection.consume_sstore()?;2478 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2479 }2480 }24812482 Ok(())2483 }24842485 fn move_token_index(2486 collection: &CollectionHandle<T>,2487 item_index: TokenId,2488 old_owner: &T::CrossAccountId,2489 new_owner: &T::CrossAccountId,2490 ) -> DispatchResult {2491 Self::remove_token_index(collection, item_index, old_owner)?;2492 Self::add_token_index(collection, item_index, new_owner)?;24932494 Ok(())2495 }2496}24972498sp_api::decl_runtime_apis! {2499 pub trait NftApi {2500 2501 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2502 }2503}