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 => match value {1615 1 => Self::burn_nft_item(collection, item_id)?,1616 0 => (),1617 _ => fail!(<Error<T>>::TokenValueTooLow),1618 },1619 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,1620 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, owner, value)?,1621 _ => (),1622 };16231624 Ok(())1625 }16261627 pub fn toggle_white_list_internal(1628 sender: &T::CrossAccountId,1629 collection: &CollectionHandle<T>,1630 address: &T::CrossAccountId,1631 whitelisted: bool,1632 ) -> DispatchResult {1633 Self::check_owner_or_admin_permissions(collection, sender)?;16341635 if whitelisted {1636 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1637 } else {1638 <WhiteList<T>>::remove(collection.id, address.as_sub());1639 }16401641 Ok(())1642 }16431644 fn is_correct_transfer(1645 collection: &CollectionHandle<T>,1646 recipient: &T::CrossAccountId,1647 ) -> DispatchResult {1648 let collection_id = collection.id;16491650 1651 collection.consume_sload()?;1652 let account_items: u32 =1653 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16541655 1656 1657 let limit = if collection.limits.account_token_ownership_limit == 01658 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1659 {1660 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1661 } else {1662 collection.limits.account_token_ownership_limit1663 };16641665 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16661667 1668 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16691670 Ok(())1671 }16721673 fn can_create_items_in_collection(1674 collection: &CollectionHandle<T>,1675 sender: &T::CrossAccountId,1676 owner: &T::CrossAccountId,1677 amount: u32,1678 ) -> DispatchResult {1679 let collection_id = collection.id;16801681 1682 let total_items: u32 = ItemListIndex::get(collection_id)1683 .checked_add(amount)1684 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1685 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1686 as u32)1687 .checked_add(amount)1688 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16891690 1691 1692 let account_token_limit = if collection.limits.account_token_ownership_limit == 01693 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1694 {1695 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1696 } else {1697 collection.limits.account_token_ownership_limit1698 };16991700 ensure!(1701 collection.limits.token_limit >= total_items,1702 Error::<T>::CollectionTokenLimitExceeded1703 );1704 ensure!(1705 account_token_limit >= account_items,1706 Error::<T>::AccountTokenLimitExceeded1707 );17081709 if !Self::is_owner_or_admin_permissions(collection, sender)? {1710 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1711 Self::check_white_list(collection, owner)?;1712 Self::check_white_list(collection, sender)?;1713 }17141715 Ok(())1716 }17171718 fn validate_create_item_args(1719 target_collection: &CollectionHandle<T>,1720 data: &CreateItemData,1721 ) -> DispatchResult {1722 match target_collection.mode {1723 CollectionMode::NFT => {1724 if !matches!(data, CreateItemData::NFT(_)) {1725 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1726 }1727 }1728 CollectionMode::Fungible(_) => {1729 if !matches!(data, CreateItemData::Fungible(_)) {1730 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1731 }1732 }1733 CollectionMode::ReFungible => {1734 if let CreateItemData::ReFungible(data) = data {1735 1736 ensure!(1737 data.pieces <= MAX_REFUNGIBLE_PIECES,1738 Error::<T>::WrongRefungiblePieces1739 );1740 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1741 } else {1742 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1743 }1744 }1745 };17461747 Ok(())1748 }17491750 fn create_item_no_validation(1751 collection: &CollectionHandle<T>,1752 owner: &T::CrossAccountId,1753 data: CreateItemData,1754 ) -> DispatchResult {1755 match data {1756 CreateItemData::NFT(data) => {1757 let item = NftItemType {1758 owner: owner.clone(),1759 const_data: data.const_data.into_inner(),1760 variable_data: data.variable_data.into_inner(),1761 };17621763 Self::add_nft_item(collection, item)?;1764 }1765 CreateItemData::Fungible(data) => {1766 Self::add_fungible_item(collection, owner, data.value)?;1767 }1768 CreateItemData::ReFungible(data) => {1769 let owner_list = vec![Ownership {1770 owner: owner.clone(),1771 fraction: data.pieces,1772 }];17731774 let item = ReFungibleItemType {1775 owner: owner_list,1776 const_data: data.const_data.into_inner(),1777 variable_data: data.variable_data.into_inner(),1778 };17791780 Self::add_refungible_item(collection, item)?;1781 }1782 };17831784 Ok(())1785 }17861787 fn add_fungible_item(1788 collection: &CollectionHandle<T>,1789 owner: &T::CrossAccountId,1790 value: u128,1791 ) -> DispatchResult {1792 let collection_id = collection.id;17931794 1795 collection.consume_sload()?;1796 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17971798 1799 let item = FungibleItemType {1800 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1801 };1802 collection.consume_sstore()?;1803 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18041805 1806 collection.consume_sload()?;1807 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1808 .checked_add(value)1809 .ok_or(Error::<T>::NumOverflow)?;1810 collection.consume_sstore()?;1811 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18121813 collection.log(ERC20Events::Transfer {1814 from: H160::default(),1815 to: *owner.as_eth(),1816 value: value.into(),1817 })?;1818 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1819 Ok(())1820 }18211822 fn add_refungible_item(1823 collection: &CollectionHandle<T>,1824 item: ReFungibleItemType<T::CrossAccountId>,1825 ) -> DispatchResult {1826 let collection_id = collection.id;18271828 let current_index = <ItemListIndex>::get(collection_id)1829 .checked_add(1)1830 .ok_or(Error::<T>::NumOverflow)?;1831 let itemcopy = item.clone();18321833 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1834 let item_owner = item.owner.first().expect("only one owner is defined");18351836 let value = item_owner.fraction;1837 let owner = item_owner.owner.clone();18381839 Self::add_token_index(collection, current_index, &owner)?;18401841 <ItemListIndex>::insert(collection_id, current_index);1842 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18431844 1845 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1846 .checked_add(value)1847 .ok_or(Error::<T>::NumOverflow)?;1848 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18491850 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1851 Ok(())1852 }18531854 fn add_nft_item(1855 collection: &CollectionHandle<T>,1856 item: NftItemType<T::CrossAccountId>,1857 ) -> DispatchResult {1858 let collection_id = collection.id;18591860 let current_index = <ItemListIndex>::get(collection_id)1861 .checked_add(1)1862 .ok_or(Error::<T>::NumOverflow)?;18631864 let item_owner = item.owner.clone();1865 Self::add_token_index(collection, current_index, &item.owner)?;18661867 <ItemListIndex>::insert(collection_id, current_index);1868 <NftItemList<T>>::insert(collection_id, current_index, item);18691870 1871 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1872 .checked_add(1)1873 .ok_or(Error::<T>::NumOverflow)?;1874 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18751876 collection.log(ERC721Events::Transfer {1877 from: H160::default(),1878 to: *item_owner.as_eth(),1879 token_id: current_index.into(),1880 })?;1881 Self::deposit_event(RawEvent::ItemCreated(1882 collection_id,1883 current_index,1884 item_owner,1885 ));1886 Ok(())1887 }18881889 fn burn_refungible_item(1890 collection: &CollectionHandle<T>,1891 item_id: TokenId,1892 owner: &T::CrossAccountId,1893 value: u128,1894 ) -> DispatchResult {1895 let collection_id = collection.id;18961897 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1898 .ok_or(Error::<T>::TokenNotFound)?;1899 let mut rft_balance = token1900 .owner1901 .iter()1902 .find(|&i| i.owner == *owner)1903 .ok_or(Error::<T>::TokenNotFound)?1904 .clone();1905 Self::remove_token_index(collection, item_id, owner)?;19061907 1908 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1909 .checked_sub(value)1910 .ok_or(Error::<T>::NumOverflow)?;1911 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19121913 rft_balance.fraction = (rft_balance.fraction)1914 .checked_sub(value)1915 .ok_or(Error::<T>::NumOverflow)?;19161917 let index = token1918 .owner1919 .iter()1920 .position(|i| i.owner == *owner)1921 .expect("owned item is exists");1922 if rft_balance.fraction == 0 {1923 1924 token.owner.remove(index);1925 } else {1926 token.owner[index] = rft_balance;1927 }19281929 let owner_count = token.owner.len();19301931 1932 if owner_count == 0 {1933 <ReFungibleItemList<T>>::remove(collection_id, item_id);1934 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1935 } else {1936 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1937 }19381939 Ok(())1940 }19411942 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1943 let collection_id = collection.id;19441945 let item =1946 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1947 Self::remove_token_index(collection, item_id, &item.owner)?;19481949 1950 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1951 .checked_sub(1)1952 .ok_or(Error::<T>::NumOverflow)?;1953 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1954 <NftItemList<T>>::remove(collection_id, item_id);1955 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19561957 collection.log(ERC721Events::Transfer {1958 from: *item.owner.as_eth(),1959 to: H160::default(),1960 token_id: item_id.into(),1961 })?;1962 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1963 Ok(())1964 }19651966 fn burn_fungible_item(1967 collection: &CollectionHandle<T>,1968 owner: &T::CrossAccountId,1969 value: u128,1970 ) -> DispatchResult {1971 let collection_id = collection.id;19721973 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1974 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19751976 1977 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1978 .checked_sub(value)1979 .ok_or(Error::<T>::NumOverflow)?;1980 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19811982 if balance.value - value > 0 {1983 balance.value -= value;1984 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1985 } else {1986 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1987 }19881989 collection.log(ERC20Events::Transfer {1990 from: *owner.as_eth(),1991 to: H160::default(),1992 value: value.into(),1993 })?;1994 Ok(())1995 }19961997 pub fn get_collection(1998 collection_id: CollectionId,1999 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2000 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)2001 }20022003 fn check_owner_permissions(2004 target_collection: &CollectionHandle<T>,2005 subject: &T::AccountId,2006 ) -> DispatchResult {2007 ensure!(2008 *subject == target_collection.owner,2009 Error::<T>::NoPermission2010 );20112012 Ok(())2013 }20142015 fn is_owner_or_admin_permissions(2016 collection: &CollectionHandle<T>,2017 subject: &T::CrossAccountId,2018 ) -> Result<bool, DispatchError> {2019 collection.consume_sload()?;2020 Ok(*subject.as_sub() == collection.owner2021 || <AdminList<T>>::get(collection.id).contains(subject))2022 }20232024 fn check_owner_or_admin_permissions(2025 collection: &CollectionHandle<T>,2026 subject: &T::CrossAccountId,2027 ) -> DispatchResult {2028 ensure!(2029 Self::is_owner_or_admin_permissions(collection, subject)?,2030 Error::<T>::NoPermission2031 );20322033 Ok(())2034 }20352036 fn owned_amount(2037 subject: &T::CrossAccountId,2038 collection: &CollectionHandle<T>,2039 item_id: TokenId,2040 ) -> Result<Option<u128>, DispatchError> {2041 collection.consume_sload()?;2042 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2043 }20442045 fn owned_amount_unchecked(2046 subject: &T::CrossAccountId,2047 target_collection: &CollectionHandle<T>,2048 item_id: TokenId,2049 ) -> Option<u128> {2050 let collection_id = target_collection.id;20512052 match target_collection.mode {2053 CollectionMode::NFT => {2054 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2055 }2056 CollectionMode::Fungible(_) => {2057 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2058 }2059 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2060 .owner2061 .iter()2062 .find(|i| i.owner == *subject)2063 .map(|i| i.fraction),2064 }2065 }20662067 fn is_item_owner(2068 subject: &T::CrossAccountId,2069 target_collection: &CollectionHandle<T>,2070 item_id: TokenId,2071 ) -> Result<bool, DispatchError> {2072 Ok(match target_collection.mode {2073 CollectionMode::Fungible(_) => true,2074 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2075 })2076 }20772078 fn check_white_list(2079 collection: &CollectionHandle<T>,2080 address: &T::CrossAccountId,2081 ) -> DispatchResult {2082 collection.consume_sload()?;2083 ensure!(2084 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2085 Error::<T>::AddresNotInWhiteList,2086 );2087 Ok(())2088 }20892090 2091 2092 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2093 let collection_id = target_collection.id;2094 let exists = match target_collection.mode {2095 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2096 CollectionMode::Fungible(_) => true,2097 CollectionMode::ReFungible => {2098 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2099 }2100 };21012102 ensure!(exists, Error::<T>::TokenNotFound);2103 Ok(())2104 }21052106 fn transfer_fungible(2107 collection: &CollectionHandle<T>,2108 value: u128,2109 owner: &T::CrossAccountId,2110 recipient: &T::CrossAccountId,2111 ) -> DispatchResult {2112 let collection_id = collection.id;21132114 collection.consume_sload()?;2115 collection.consume_sload()?;2116 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2117 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21182119 recipient_balance.value = recipient_balance2120 .value2121 .checked_add(value)2122 .ok_or(Error::<T>::NumOverflow)?;2123 balance.value = balance2124 .value2125 .checked_sub(value)2126 .ok_or(Error::<T>::TokenValueTooLow)?;21272128 2129 collection.consume_sstore()?;2130 collection.consume_sstore()?;2131 if balance.value != 0 {2132 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2133 } else {2134 <Balance<T>>::remove(collection_id, owner.as_sub());2135 }2136 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21372138 2139 collection.consume_sstore()?;2140 collection.consume_sstore()?;2141 if balance.value != 0 {2142 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2143 } else {2144 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2145 }2146 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21472148 collection.log(ERC20Events::Transfer {2149 from: *owner.as_eth(),2150 to: *recipient.as_eth(),2151 value: value.into(),2152 })?;2153 Self::deposit_event(RawEvent::Transfer(2154 collection.id,2155 1,2156 owner.clone(),2157 recipient.clone(),2158 value,2159 ));21602161 Ok(())2162 }21632164 fn transfer_refungible(2165 collection: &CollectionHandle<T>,2166 item_id: TokenId,2167 value: u128,2168 owner: T::CrossAccountId,2169 new_owner: T::CrossAccountId,2170 ) -> DispatchResult {2171 let collection_id = collection.id;2172 collection.consume_sload()?;2173 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2174 .ok_or(Error::<T>::TokenNotFound)?;21752176 let item = full_item2177 .owner2178 .iter()2179 .find(|i| i.owner == owner)2180 .ok_or(Error::<T>::TokenNotFound)?;2181 let amount = item.fraction;21822183 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21842185 collection.consume_sload()?;2186 2187 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2188 .checked_sub(value)2189 .ok_or(Error::<T>::NumOverflow)?;2190 collection.consume_sstore()?;2191 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21922193 collection.consume_sload()?;2194 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2195 .checked_add(value)2196 .ok_or(Error::<T>::NumOverflow)?;2197 collection.consume_sstore()?;2198 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21992200 let old_owner = item.owner.clone();2201 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22022203 let mut new_full_item = full_item.clone();2204 2205 if amount == value && !new_owner_has_account {2206 2207 2208 new_full_item2209 .owner2210 .iter_mut()2211 .find(|i| i.owner == owner)2212 .expect("old owner does present in refungible")2213 .owner = new_owner.clone();2214 collection.consume_sstore()?;2215 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22162217 2218 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2219 } else {2220 new_full_item2221 .owner2222 .iter_mut()2223 .find(|i| i.owner == owner)2224 .expect("old owner does present in refungible")2225 .fraction -= value;22262227 2228 if new_owner_has_account {2229 2230 new_full_item2231 .owner2232 .iter_mut()2233 .find(|i| i.owner == new_owner)2234 .expect("new owner has account")2235 .fraction += value;2236 } else {2237 2238 new_full_item.owner.push(Ownership {2239 owner: new_owner.clone(),2240 fraction: value,2241 });2242 Self::add_token_index(collection, item_id, &new_owner)?;2243 }22442245 collection.consume_sstore()?;2246 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2247 }22482249 Self::deposit_event(RawEvent::Transfer(2250 collection.id,2251 item_id,2252 owner,2253 new_owner,2254 amount,2255 ));22562257 Ok(())2258 }22592260 fn transfer_nft(2261 collection: &CollectionHandle<T>,2262 item_id: TokenId,2263 sender: T::CrossAccountId,2264 new_owner: T::CrossAccountId,2265 ) -> DispatchResult {2266 let collection_id = collection.id;2267 collection.consume_sload()?;2268 let mut item =2269 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22702271 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22722273 collection.consume_sload()?;2274 2275 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2276 .checked_sub(1)2277 .ok_or(Error::<T>::NumOverflow)?;2278 collection.consume_sstore()?;2279 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22802281 collection.consume_sload()?;2282 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2283 .checked_add(1)2284 .ok_or(Error::<T>::NumOverflow)?;2285 collection.consume_sstore()?;2286 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22872288 2289 let old_owner = item.owner.clone();2290 item.owner = new_owner.clone();2291 collection.consume_sstore()?;2292 <NftItemList<T>>::insert(collection_id, item_id, item);22932294 2295 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22962297 collection.log(ERC721Events::Transfer {2298 from: *sender.as_eth(),2299 to: *new_owner.as_eth(),2300 token_id: item_id.into(),2301 })?;2302 Self::deposit_event(RawEvent::Transfer(2303 collection.id,2304 item_id,2305 sender,2306 new_owner,2307 1,2308 ));23092310 Ok(())2311 }23122313 fn set_re_fungible_variable_data(2314 collection: &CollectionHandle<T>,2315 item_id: TokenId,2316 data: Vec<u8>,2317 ) -> DispatchResult {2318 let collection_id = collection.id;2319 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2320 .ok_or(Error::<T>::TokenNotFound)?;23212322 item.variable_data = data;23232324 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23252326 Ok(())2327 }23282329 fn set_nft_variable_data(2330 collection: &CollectionHandle<T>,2331 item_id: TokenId,2332 data: Vec<u8>,2333 ) -> DispatchResult {2334 let collection_id = collection.id;2335 let mut item =2336 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23372338 item.variable_data = data;23392340 <NftItemList<T>>::insert(collection_id, item_id, item);23412342 Ok(())2343 }23442345 #[allow(dead_code)]2346 fn init_collection(item: &Collection<T>) {2347 2348 assert!(2349 item.decimal_points <= MAX_DECIMAL_POINTS,2350 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2351 );2352 assert!(2353 item.name.len() <= 64,2354 "Collection name can not be longer than 63 char"2355 );2356 assert!(2357 item.name.len() <= 256,2358 "Collection description can not be longer than 255 char"2359 );2360 assert!(2361 item.token_prefix.len() <= 16,2362 "Token prefix can not be longer than 15 char"2363 );23642365 2366 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23672368 CreatedCollectionCount::put(next_id);2369 }23702371 #[allow(dead_code)]2372 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2373 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23742375 Self::add_token_index(2376 &CollectionHandle::get(collection_id).unwrap(),2377 current_index,2378 &item.owner,2379 )2380 .unwrap();23812382 <ItemListIndex>::insert(collection_id, current_index);23832384 2385 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2386 .checked_add(1)2387 .unwrap();2388 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2389 }23902391 #[allow(dead_code)]2392 fn init_fungible_token(2393 collection_id: CollectionId,2394 owner: &T::CrossAccountId,2395 item: &FungibleItemType,2396 ) {2397 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23982399 Self::add_token_index(2400 &CollectionHandle::get(collection_id).unwrap(),2401 current_index,2402 owner,2403 )2404 .unwrap();24052406 <ItemListIndex>::insert(collection_id, current_index);24072408 2409 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2410 .checked_add(item.value)2411 .unwrap();2412 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2413 }24142415 #[allow(dead_code)]2416 fn init_refungible_token(2417 collection_id: CollectionId,2418 item: &ReFungibleItemType<T::CrossAccountId>,2419 ) {2420 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24212422 let value = item.owner.first().unwrap().fraction;2423 let owner = item.owner.first().unwrap().owner.clone();24242425 Self::add_token_index(2426 &CollectionHandle::get(collection_id).unwrap(),2427 current_index,2428 &owner,2429 )2430 .unwrap();24312432 <ItemListIndex>::insert(collection_id, current_index);24332434 2435 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2436 .checked_add(value)2437 .unwrap();2438 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2439 }24402441 fn add_token_index(2442 collection: &CollectionHandle<T>,2443 item_index: TokenId,2444 owner: &T::CrossAccountId,2445 ) -> DispatchResult {2446 collection.consume_sload()?;2447 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2448 if list_exists {2449 collection.consume_sload()?;2450 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24512452 2453 let account_items: u32 = list.len() as u32;2454 ensure!(2455 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2456 Error::<T>::AddressOwnershipLimitExceeded2457 );24582459 let item_contains = list.contains(&item_index.clone());24602461 if !item_contains {2462 list.push(item_index);2463 }24642465 collection.consume_sstore()?;2466 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2467 } else {2468 let itm = vec![item_index];2469 collection.consume_sstore()?;2470 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2471 }24722473 Ok(())2474 }24752476 fn remove_token_index(2477 collection: &CollectionHandle<T>,2478 item_index: TokenId,2479 owner: &T::CrossAccountId,2480 ) -> DispatchResult {2481 collection.consume_sload()?;2482 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2483 if list_exists {2484 collection.consume_sload()?;2485 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2486 let item_contains = list.contains(&item_index.clone());24872488 if item_contains {2489 list.retain(|&item| item != item_index);2490 collection.consume_sstore()?;2491 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2492 }2493 }24942495 Ok(())2496 }24972498 fn move_token_index(2499 collection: &CollectionHandle<T>,2500 item_index: TokenId,2501 old_owner: &T::CrossAccountId,2502 new_owner: &T::CrossAccountId,2503 ) -> DispatchResult {2504 Self::remove_token_index(collection, item_index, old_owner)?;2505 Self::add_token_index(collection, item_index, new_owner)?;25062507 Ok(())2508 }2509}25102511sp_api::decl_runtime_apis! {2512 pub trait NftApi {2513 2514 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2515 }2516}