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 value: u128,1892 ) -> DispatchResult {1893 let collection_id = collection.id;18941895 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1896 .ok_or(Error::<T>::TokenNotFound)?;1897 let mut rft_balance = token1898 .owner1899 .iter()1900 .find(|&i| i.owner == *owner)1901 .ok_or(Error::<T>::TokenNotFound)?1902 .clone();1903 Self::remove_token_index(collection, item_id, owner)?;19041905 1906 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1907 .checked_sub(value)1908 .ok_or(Error::<T>::NumOverflow)?;1909 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19101911 rft_balance.fraction = (rft_balance.fraction)1912 .checked_sub(value)1913 .ok_or(Error::<T>::NumOverflow)?;19141915 let index = token1916 .owner1917 .iter()1918 .position(|i| i.owner == *owner)1919 .expect("owned item is exists");1920 if rft_balance.fraction == 0 {1921 1922 token.owner.remove(index);1923 } else {1924 token.owner[index] = rft_balance;1925 }19261927 let owner_count = token.owner.len();19281929 1930 if owner_count == 0 {1931 <ReFungibleItemList<T>>::remove(collection_id, item_id);1932 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1933 } else {1934 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1935 }19361937 Ok(())1938 }19391940 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1941 let collection_id = collection.id;19421943 let item =1944 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1945 Self::remove_token_index(collection, item_id, &item.owner)?;19461947 1948 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1949 .checked_sub(1)1950 .ok_or(Error::<T>::NumOverflow)?;1951 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1952 <NftItemList<T>>::remove(collection_id, item_id);1953 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19541955 collection.log(ERC721Events::Transfer {1956 from: *item.owner.as_eth(),1957 to: H160::default(),1958 token_id: item_id.into(),1959 })?;1960 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1961 Ok(())1962 }19631964 fn burn_fungible_item(1965 collection: &CollectionHandle<T>,1966 owner: &T::CrossAccountId,1967 value: u128,1968 ) -> DispatchResult {1969 let collection_id = collection.id;19701971 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1972 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19731974 1975 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1976 .checked_sub(value)1977 .ok_or(Error::<T>::NumOverflow)?;1978 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19791980 if balance.value - value > 0 {1981 balance.value -= value;1982 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1983 } else {1984 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1985 }19861987 collection.log(ERC20Events::Transfer {1988 from: *owner.as_eth(),1989 to: H160::default(),1990 value: value.into(),1991 })?;1992 Ok(())1993 }19941995 pub fn get_collection(1996 collection_id: CollectionId,1997 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1998 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1999 }20002001 fn check_owner_permissions(2002 target_collection: &CollectionHandle<T>,2003 subject: &T::AccountId,2004 ) -> DispatchResult {2005 ensure!(2006 *subject == target_collection.owner,2007 Error::<T>::NoPermission2008 );20092010 Ok(())2011 }20122013 fn is_owner_or_admin_permissions(2014 collection: &CollectionHandle<T>,2015 subject: &T::CrossAccountId,2016 ) -> Result<bool, DispatchError> {2017 collection.consume_sload()?;2018 Ok(*subject.as_sub() == collection.owner2019 || <AdminList<T>>::get(collection.id).contains(subject))2020 }20212022 fn check_owner_or_admin_permissions(2023 collection: &CollectionHandle<T>,2024 subject: &T::CrossAccountId,2025 ) -> DispatchResult {2026 ensure!(2027 Self::is_owner_or_admin_permissions(collection, subject)?,2028 Error::<T>::NoPermission2029 );20302031 Ok(())2032 }20332034 fn owned_amount(2035 subject: &T::CrossAccountId,2036 collection: &CollectionHandle<T>,2037 item_id: TokenId,2038 ) -> Result<Option<u128>, DispatchError> {2039 collection.consume_sload()?;2040 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2041 }20422043 fn owned_amount_unchecked(2044 subject: &T::CrossAccountId,2045 target_collection: &CollectionHandle<T>,2046 item_id: TokenId,2047 ) -> Option<u128> {2048 let collection_id = target_collection.id;20492050 match target_collection.mode {2051 CollectionMode::NFT => {2052 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2053 }2054 CollectionMode::Fungible(_) => {2055 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2056 }2057 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2058 .owner2059 .iter()2060 .find(|i| i.owner == *subject)2061 .map(|i| i.fraction),2062 }2063 }20642065 fn is_item_owner(2066 subject: &T::CrossAccountId,2067 target_collection: &CollectionHandle<T>,2068 item_id: TokenId,2069 ) -> Result<bool, DispatchError> {2070 Ok(match target_collection.mode {2071 CollectionMode::Fungible(_) => true,2072 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2073 })2074 }20752076 fn check_white_list(2077 collection: &CollectionHandle<T>,2078 address: &T::CrossAccountId,2079 ) -> DispatchResult {2080 collection.consume_sload()?;2081 ensure!(2082 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2083 Error::<T>::AddresNotInWhiteList,2084 );2085 Ok(())2086 }20872088 2089 2090 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2091 let collection_id = target_collection.id;2092 let exists = match target_collection.mode {2093 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2094 CollectionMode::Fungible(_) => true,2095 CollectionMode::ReFungible => {2096 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2097 }2098 };20992100 ensure!(exists, Error::<T>::TokenNotFound);2101 Ok(())2102 }21032104 fn transfer_fungible(2105 collection: &CollectionHandle<T>,2106 value: u128,2107 owner: &T::CrossAccountId,2108 recipient: &T::CrossAccountId,2109 ) -> DispatchResult {2110 let collection_id = collection.id;21112112 collection.consume_sload()?;2113 collection.consume_sload()?;2114 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2115 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21162117 recipient_balance.value = recipient_balance2118 .value2119 .checked_add(value)2120 .ok_or(Error::<T>::NumOverflow)?;2121 balance.value = balance2122 .value2123 .checked_sub(value)2124 .ok_or(Error::<T>::TokenValueTooLow)?;21252126 2127 collection.consume_sstore()?;2128 collection.consume_sstore()?;2129 if balance.value != 0 {2130 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2131 } else {2132 <Balance<T>>::remove(collection_id, owner.as_sub());2133 }2134 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21352136 2137 collection.consume_sstore()?;2138 collection.consume_sstore()?;2139 if balance.value != 0 {2140 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2141 } else {2142 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2143 }2144 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21452146 collection.log(ERC20Events::Transfer {2147 from: *owner.as_eth(),2148 to: *recipient.as_eth(),2149 value: value.into(),2150 })?;2151 Self::deposit_event(RawEvent::Transfer(2152 collection.id,2153 1,2154 owner.clone(),2155 recipient.clone(),2156 value,2157 ));21582159 Ok(())2160 }21612162 fn transfer_refungible(2163 collection: &CollectionHandle<T>,2164 item_id: TokenId,2165 value: u128,2166 owner: T::CrossAccountId,2167 new_owner: T::CrossAccountId,2168 ) -> DispatchResult {2169 let collection_id = collection.id;2170 collection.consume_sload()?;2171 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2172 .ok_or(Error::<T>::TokenNotFound)?;21732174 let item = full_item2175 .owner2176 .iter()2177 .find(|i| i.owner == owner)2178 .ok_or(Error::<T>::TokenNotFound)?;2179 let amount = item.fraction;21802181 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21822183 collection.consume_sload()?;2184 2185 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2186 .checked_sub(value)2187 .ok_or(Error::<T>::NumOverflow)?;2188 collection.consume_sstore()?;2189 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21902191 collection.consume_sload()?;2192 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2193 .checked_add(value)2194 .ok_or(Error::<T>::NumOverflow)?;2195 collection.consume_sstore()?;2196 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21972198 let old_owner = item.owner.clone();2199 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22002201 let mut new_full_item = full_item.clone();2202 2203 if amount == value && !new_owner_has_account {2204 2205 2206 new_full_item2207 .owner2208 .iter_mut()2209 .find(|i| i.owner == owner)2210 .expect("old owner does present in refungible")2211 .owner = new_owner.clone();2212 collection.consume_sstore()?;2213 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22142215 2216 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2217 } else {2218 new_full_item2219 .owner2220 .iter_mut()2221 .find(|i| i.owner == owner)2222 .expect("old owner does present in refungible")2223 .fraction -= value;22242225 2226 if new_owner_has_account {2227 2228 new_full_item2229 .owner2230 .iter_mut()2231 .find(|i| i.owner == new_owner)2232 .expect("new owner has account")2233 .fraction += value;2234 } else {2235 2236 new_full_item.owner.push(Ownership {2237 owner: new_owner.clone(),2238 fraction: value,2239 });2240 Self::add_token_index(collection, item_id, &new_owner)?;2241 }22422243 collection.consume_sstore()?;2244 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2245 }22462247 Self::deposit_event(RawEvent::Transfer(2248 collection.id,2249 item_id,2250 owner,2251 new_owner,2252 amount,2253 ));22542255 Ok(())2256 }22572258 fn transfer_nft(2259 collection: &CollectionHandle<T>,2260 item_id: TokenId,2261 sender: T::CrossAccountId,2262 new_owner: T::CrossAccountId,2263 ) -> DispatchResult {2264 let collection_id = collection.id;2265 collection.consume_sload()?;2266 let mut item =2267 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22682269 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22702271 collection.consume_sload()?;2272 2273 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2274 .checked_sub(1)2275 .ok_or(Error::<T>::NumOverflow)?;2276 collection.consume_sstore()?;2277 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22782279 collection.consume_sload()?;2280 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2281 .checked_add(1)2282 .ok_or(Error::<T>::NumOverflow)?;2283 collection.consume_sstore()?;2284 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22852286 2287 let old_owner = item.owner.clone();2288 item.owner = new_owner.clone();2289 collection.consume_sstore()?;2290 <NftItemList<T>>::insert(collection_id, item_id, item);22912292 2293 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22942295 collection.log(ERC721Events::Transfer {2296 from: *sender.as_eth(),2297 to: *new_owner.as_eth(),2298 token_id: item_id.into(),2299 })?;2300 Self::deposit_event(RawEvent::Transfer(2301 collection.id,2302 item_id,2303 sender,2304 new_owner,2305 1,2306 ));23072308 Ok(())2309 }23102311 fn set_re_fungible_variable_data(2312 collection: &CollectionHandle<T>,2313 item_id: TokenId,2314 data: Vec<u8>,2315 ) -> DispatchResult {2316 let collection_id = collection.id;2317 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2318 .ok_or(Error::<T>::TokenNotFound)?;23192320 item.variable_data = data;23212322 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23232324 Ok(())2325 }23262327 fn set_nft_variable_data(2328 collection: &CollectionHandle<T>,2329 item_id: TokenId,2330 data: Vec<u8>,2331 ) -> DispatchResult {2332 let collection_id = collection.id;2333 let mut item =2334 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23352336 item.variable_data = data;23372338 <NftItemList<T>>::insert(collection_id, item_id, item);23392340 Ok(())2341 }23422343 #[allow(dead_code)]2344 fn init_collection(item: &Collection<T>) {2345 2346 assert!(2347 item.decimal_points <= MAX_DECIMAL_POINTS,2348 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2349 );2350 assert!(2351 item.name.len() <= 64,2352 "Collection name can not be longer than 63 char"2353 );2354 assert!(2355 item.name.len() <= 256,2356 "Collection description can not be longer than 255 char"2357 );2358 assert!(2359 item.token_prefix.len() <= 16,2360 "Token prefix can not be longer than 15 char"2361 );23622363 2364 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23652366 CreatedCollectionCount::put(next_id);2367 }23682369 #[allow(dead_code)]2370 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2371 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23722373 Self::add_token_index(2374 &CollectionHandle::get(collection_id).unwrap(),2375 current_index,2376 &item.owner,2377 )2378 .unwrap();23792380 <ItemListIndex>::insert(collection_id, current_index);23812382 2383 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2384 .checked_add(1)2385 .unwrap();2386 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2387 }23882389 #[allow(dead_code)]2390 fn init_fungible_token(2391 collection_id: CollectionId,2392 owner: &T::CrossAccountId,2393 item: &FungibleItemType,2394 ) {2395 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23962397 Self::add_token_index(2398 &CollectionHandle::get(collection_id).unwrap(),2399 current_index,2400 owner,2401 )2402 .unwrap();24032404 <ItemListIndex>::insert(collection_id, current_index);24052406 2407 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2408 .checked_add(item.value)2409 .unwrap();2410 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2411 }24122413 #[allow(dead_code)]2414 fn init_refungible_token(2415 collection_id: CollectionId,2416 item: &ReFungibleItemType<T::CrossAccountId>,2417 ) {2418 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24192420 let value = item.owner.first().unwrap().fraction;2421 let owner = item.owner.first().unwrap().owner.clone();24222423 Self::add_token_index(2424 &CollectionHandle::get(collection_id).unwrap(),2425 current_index,2426 &owner,2427 )2428 .unwrap();24292430 <ItemListIndex>::insert(collection_id, current_index);24312432 2433 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2434 .checked_add(value)2435 .unwrap();2436 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2437 }24382439 fn add_token_index(2440 collection: &CollectionHandle<T>,2441 item_index: TokenId,2442 owner: &T::CrossAccountId,2443 ) -> DispatchResult {2444 collection.consume_sload()?;2445 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2446 if list_exists {2447 collection.consume_sload()?;2448 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24492450 2451 let account_items: u32 = list.len() as u32;2452 ensure!(2453 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2454 Error::<T>::AddressOwnershipLimitExceeded2455 );24562457 let item_contains = list.contains(&item_index.clone());24582459 if !item_contains {2460 list.push(item_index);2461 }24622463 collection.consume_sstore()?;2464 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2465 } else {2466 let itm = vec![item_index];2467 collection.consume_sstore()?;2468 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2469 }24702471 Ok(())2472 }24732474 fn remove_token_index(2475 collection: &CollectionHandle<T>,2476 item_index: TokenId,2477 owner: &T::CrossAccountId,2478 ) -> DispatchResult {2479 collection.consume_sload()?;2480 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2481 if list_exists {2482 collection.consume_sload()?;2483 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2484 let item_contains = list.contains(&item_index.clone());24852486 if item_contains {2487 list.retain(|&item| item != item_index);2488 collection.consume_sstore()?;2489 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2490 }2491 }24922493 Ok(())2494 }24952496 fn move_token_index(2497 collection: &CollectionHandle<T>,2498 item_index: TokenId,2499 old_owner: &T::CrossAccountId,2500 new_owner: &T::CrossAccountId,2501 ) -> DispatchResult {2502 Self::remove_token_index(collection, item_index, old_owner)?;2503 Self::add_token_index(collection, item_index, new_owner)?;25042505 Ok(())2506 }2507}25082509sp_api::decl_runtime_apis! {2510 pub trait NftApi {2511 2512 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2513 }2514}