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, value: u128) -> DispatchResult {991992 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993 let target_collection = Self::get_collection(collection_id)?;994995 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;996997 target_collection.submit_logs()998 }9991000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 #[weight = <SelfWeightOf<T>>::transfer()]1024 #[transactional]1025 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027 let collection = Self::get_collection(collection_id)?;10281029 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031 collection.submit_logs()1032 }10331034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 #[weight = <SelfWeightOf<T>>::approve()]1050 #[transactional]1051 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053 let collection = Self::get_collection(collection_id)?;10541055 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057 collection.submit_logs()1058 }10591060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 #[weight = <SelfWeightOf<T>>::transfer_from()]1080 #[transactional]1081 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083 let collection = Self::get_collection(collection_id)?;10841085 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087 collection.submit_logs()1088 }1089 1090 1091 1092 1093 10941095 10961097 10981099 1100 11011102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115 #[transactional]1116 pub fn set_variable_meta_data (1117 origin,1118 collection_id: CollectionId,1119 item_id: TokenId,1120 data: Vec<u8>1121 ) -> DispatchResult {1122 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124 let collection = Self::get_collection(collection_id)?;1125 Self::meta_update_check(&sender, &collection, item_id)?;11261127 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129 Ok(())1130 }11311132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 #[weight = <SelfWeightOf<T>>::set_schema_version()]1147 #[transactional]1148 pub fn set_schema_version(1149 origin,1150 collection_id: CollectionId,1151 version: SchemaVersion1152 ) -> DispatchResult {1153 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154 let mut target_collection = Self::get_collection(collection_id)?;1155 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156 target_collection.schema_version = version;1157 target_collection.save()1158 }11591160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173 #[transactional]1174 pub fn set_offchain_schema(1175 origin,1176 collection_id: CollectionId,1177 schema: Vec<u8>1178 ) -> DispatchResult {1179 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180 let mut target_collection = Self::get_collection(collection_id)?;1181 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183 1184 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186 target_collection.offchain_schema = schema;1187 target_collection.save()1188 }11891190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203 #[transactional]1204 pub fn set_const_on_chain_schema (1205 origin,1206 collection_id: CollectionId,1207 schema: Vec<u8>1208 ) -> DispatchResult {1209 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210 let mut target_collection = Self::get_collection(collection_id)?;1211 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213 1214 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216 target_collection.const_on_chain_schema = schema;1217 target_collection.save()1218 }12191220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233 #[transactional]1234 pub fn set_variable_on_chain_schema (1235 origin,1236 collection_id: CollectionId,1237 schema: Vec<u8>1238 ) -> DispatchResult {1239 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240 let mut target_collection = Self::get_collection(collection_id)?;1241 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243 1244 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246 target_collection.variable_on_chain_schema = schema;1247 target_collection.save()1248 }12491250 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1251 #[transactional]1252 pub fn set_collection_limits(1253 origin,1254 collection_id: u32,1255 new_limits: CollectionLimits<T::BlockNumber>,1256 ) -> DispatchResult {1257 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258 let mut target_collection = Self::get_collection(collection_id)?;1259 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260 let old_limits = &target_collection.limits;12611262 1263 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266 Error::<T>::CollectionLimitBoundsExceeded);12671268 1269 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272 ensure!(1273 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275 Error::<T>::OwnerPermissionsCantBeReverted,1276 );12771278 target_collection.limits = new_limits;12791280 target_collection.save()1281 }1282 }1283}12841285impl<T: Config> Module<T> {1286 pub fn create_item_internal(1287 sender: &T::CrossAccountId,1288 collection: &CollectionHandle<T>,1289 owner: &T::CrossAccountId,1290 data: CreateItemData,1291 ) -> DispatchResult {1292 ensure!(1293 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294 Error::<T>::AddressIsZero1295 );12961297 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298 Self::validate_create_item_args(collection, &data)?;1299 Self::create_item_no_validation(collection, owner, data)?;13001301 Ok(())1302 }13031304 pub fn transfer_internal(1305 sender: &T::CrossAccountId,1306 recipient: &T::CrossAccountId,1307 target_collection: &CollectionHandle<T>,1308 item_id: TokenId,1309 value: u128,1310 ) -> DispatchResult {1311 ensure!(1312 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313 Error::<T>::AddressIsZero1314 );13151316 1317 Self::is_correct_transfer(target_collection, recipient)?;13181319 1320 ensure!(1321 Self::is_item_owner(sender, target_collection, item_id)?1322 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1323 Error::<T>::NoPermission1324 );13251326 if target_collection.access == AccessMode::WhiteList {1327 Self::check_white_list(target_collection, sender)?;1328 Self::check_white_list(target_collection, recipient)?;1329 }13301331 match target_collection.mode {1332 CollectionMode::NFT => Self::transfer_nft(1333 target_collection,1334 item_id,1335 sender.clone(),1336 recipient.clone(),1337 )?,1338 CollectionMode::Fungible(_) => {1339 Self::transfer_fungible(target_collection, value, sender, recipient)?1340 }1341 CollectionMode::ReFungible => Self::transfer_refungible(1342 target_collection,1343 item_id,1344 value,1345 sender.clone(),1346 recipient.clone(),1347 )?,1348 _ => (),1349 };13501351 Self::deposit_event(RawEvent::Transfer(1352 target_collection.id,1353 item_id,1354 sender.clone(),1355 recipient.clone(),1356 value,1357 ));13581359 Ok(())1360 }13611362 pub fn approve_internal(1363 sender: &T::CrossAccountId,1364 spender: &T::CrossAccountId,1365 collection: &CollectionHandle<T>,1366 item_id: TokenId,1367 amount: u128,1368 ) -> DispatchResult {1369 Self::token_exists(collection, item_id)?;13701371 1372 let bypasses_limits = collection.limits.owner_can_transfer1373 && Self::is_owner_or_admin_permissions(collection, sender)?;13741375 let allowance_limit = if bypasses_limits {1376 None1377 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1378 Some(amount)1379 } else {1380 fail!(Error::<T>::NoPermission);1381 };13821383 if collection.access == AccessMode::WhiteList {1384 Self::check_white_list(collection, sender)?;1385 Self::check_white_list(collection, spender)?;1386 }13871388 collection.consume_sload()?;1389 let allowance: u128 = amount1390 .checked_add(<Allowances<T>>::get(1391 collection.id,1392 (item_id, sender.as_sub(), spender.as_sub()),1393 ))1394 .ok_or(Error::<T>::NumOverflow)?;1395 if let Some(limit) = allowance_limit {1396 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1397 }1398 collection.consume_sstore()?;1399 <Allowances<T>>::insert(1400 collection.id,1401 (item_id, sender.as_sub(), spender.as_sub()),1402 allowance,1403 );14041405 if matches!(collection.mode, CollectionMode::NFT) {1406 1407 collection.log(ERC721Events::Approval {1408 owner: *sender.as_eth(),1409 approved: *spender.as_eth(),1410 token_id: item_id.into(),1411 })?;1412 }14131414 if matches!(collection.mode, CollectionMode::Fungible(_)) {1415 1416 collection.log(ERC20Events::Approval {1417 owner: *sender.as_eth(),1418 spender: *spender.as_eth(),1419 value: allowance.into(),1420 })?;1421 }14221423 Self::deposit_event(RawEvent::Approved(1424 collection.id,1425 item_id,1426 sender.clone(),1427 spender.clone(),1428 allowance,1429 ));1430 Ok(())1431 }14321433 pub fn transfer_from_internal(1434 sender: &T::CrossAccountId,1435 from: &T::CrossAccountId,1436 recipient: &T::CrossAccountId,1437 collection: &CollectionHandle<T>,1438 item_id: TokenId,1439 amount: u128,1440 ) -> DispatchResult {1441 if sender == from {1442 1443 return Self::transfer_internal(from, recipient, collection, item_id, amount);1444 }14451446 1447 collection.consume_sload()?;1448 let approval: u128 =1449 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14501451 1452 Self::is_correct_transfer(collection, recipient)?;14531454 1455 ensure!(1456 approval >= amount1457 || (collection.limits.owner_can_transfer1458 && Self::is_owner_or_admin_permissions(collection, sender)?),1459 Error::<T>::NoPermission1460 );14611462 if collection.access == AccessMode::WhiteList {1463 Self::check_white_list(collection, sender)?;1464 Self::check_white_list(collection, recipient)?;1465 }14661467 1468 let allowance = approval.saturating_sub(amount);1469 collection.consume_sstore()?;1470 if allowance > 0 {1471 <Allowances<T>>::insert(1472 collection.id,1473 (item_id, from.as_sub(), sender.as_sub()),1474 allowance,1475 );1476 } else {1477 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1478 }14791480 match collection.mode {1481 CollectionMode::NFT => {1482 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1483 }1484 CollectionMode::Fungible(_) => {1485 Self::transfer_fungible(collection, amount, from, recipient)?1486 }1487 CollectionMode::ReFungible => Self::transfer_refungible(1488 collection,1489 item_id,1490 amount,1491 from.clone(),1492 recipient.clone(),1493 )?,1494 _ => (),1495 };14961497 if matches!(collection.mode, CollectionMode::Fungible(_)) {1498 collection.log(ERC20Events::Approval {1499 owner: *from.as_eth(),1500 spender: *sender.as_eth(),1501 value: allowance.into(),1502 })?;1503 }15041505 Ok(())1506 }15071508 pub fn set_variable_meta_data_internal(1509 sender: &T::CrossAccountId,1510 collection: &CollectionHandle<T>,1511 item_id: TokenId,1512 data: Vec<u8>,1513 ) -> DispatchResult {1514 Self::token_exists(collection, item_id)?;15151516 ensure!(1517 CUSTOM_DATA_LIMIT >= data.len() as u32,1518 Error::<T>::TokenVariableDataLimitExceeded1519 );15201521 ensure!(1522 (Self::is_item_owner(sender, collection, item_id)?1523 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1524 || (Self::is_owner_or_admin_permissions(collection, sender)?1525 && collection.meta_update_permission == MetaUpdatePermission::Admin),1526 Error::<T>::NoPermission1527 );15281529 match collection.mode {1530 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1531 CollectionMode::ReFungible => {1532 Self::set_re_fungible_variable_data(collection, item_id, data)?1533 }1534 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1535 _ => fail!(Error::<T>::UnexpectedCollectionType),1536 };15371538 Ok(())1539 }15401541 pub fn meta_update_check(1542 sender: &T::CrossAccountId,1543 collection: &CollectionHandle<T>,1544 item_id: TokenId,1545 ) -> DispatchResult {1546 match collection.meta_update_permission {1547 MetaUpdatePermission::ItemOwner => ensure!(1548 Self::is_item_owner(sender, collection, item_id)?,1549 Error::<T>::NoPermission1550 ),1551 MetaUpdatePermission::Admin => ensure!(1552 Self::is_owner_or_admin_permissions(collection, sender)?,1553 Error::<T>::NoPermission1554 ),1555 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1556 }15571558 Ok(())1559 }15601561 pub fn get_variable_metadata(1562 collection: &CollectionHandle<T>,1563 item_id: TokenId,1564 ) -> Result<Vec<u8>, DispatchError> {1565 Ok(match collection.mode {1566 CollectionMode::NFT => {1567 <NftItemList<T>>::get(collection.id, item_id)1568 .ok_or(Error::<T>::TokenNotFound)?1569 .variable_data1570 }1571 CollectionMode::ReFungible => {1572 <ReFungibleItemList<T>>::get(collection.id, item_id)1573 .ok_or(Error::<T>::TokenNotFound)?1574 .variable_data1575 }1576 _ => fail!(Error::<T>::UnexpectedCollectionType),1577 })1578 }15791580 pub fn create_multiple_items_internal(1581 sender: &T::CrossAccountId,1582 collection: &CollectionHandle<T>,1583 owner: &T::CrossAccountId,1584 items_data: Vec<CreateItemData>,1585 ) -> DispatchResult {1586 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15871588 for data in &items_data {1589 Self::validate_create_item_args(collection, data)?;1590 }1591 for data in &items_data {1592 Self::create_item_no_validation(collection, owner, data.clone())?;1593 }15941595 Ok(())1596 }15971598 pub fn burn_item_internal(1599 sender: &T::CrossAccountId,1600 collection: &CollectionHandle<T>,1601 item_id: TokenId,1602 value: u128,1603 ) -> DispatchResult {1604 ensure!(1605 Self::is_item_owner(sender, collection, item_id)?1606 || (collection.limits.owner_can_transfer1607 && Self::is_owner_or_admin_permissions(collection, sender)?),1608 Error::<T>::NoPermission1609 );16101611 if collection.access == AccessMode::WhiteList {1612 Self::check_white_list(collection, sender)?;1613 }16141615 match collection.mode {1616 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1617 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1618 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,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 _ => {1744 fail!(Error::<T>::UnexpectedCollectionType);1745 }1746 };17471748 Ok(())1749 }17501751 fn create_item_no_validation(1752 collection: &CollectionHandle<T>,1753 owner: &T::CrossAccountId,1754 data: CreateItemData,1755 ) -> DispatchResult {1756 match data {1757 CreateItemData::NFT(data) => {1758 let item = NftItemType {1759 owner: owner.clone(),1760 const_data: data.const_data.into_inner(),1761 variable_data: data.variable_data.into_inner(),1762 };17631764 Self::add_nft_item(collection, item)?;1765 }1766 CreateItemData::Fungible(data) => {1767 Self::add_fungible_item(collection, owner, data.value)?;1768 }1769 CreateItemData::ReFungible(data) => {1770 let owner_list = vec![Ownership {1771 owner: owner.clone(),1772 fraction: data.pieces,1773 }];17741775 let item = ReFungibleItemType {1776 owner: owner_list,1777 const_data: data.const_data.into_inner(),1778 variable_data: data.variable_data.into_inner(),1779 };17801781 Self::add_refungible_item(collection, item)?;1782 }1783 };17841785 Ok(())1786 }17871788 fn add_fungible_item(1789 collection: &CollectionHandle<T>,1790 owner: &T::CrossAccountId,1791 value: u128,1792 ) -> DispatchResult {1793 let collection_id = collection.id;17941795 1796 collection.consume_sload()?;1797 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17981799 1800 let item = FungibleItemType {1801 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1802 };1803 collection.consume_sstore()?;1804 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18051806 1807 collection.consume_sload()?;1808 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1809 .checked_add(value)1810 .ok_or(Error::<T>::NumOverflow)?;1811 collection.consume_sstore()?;1812 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18131814 collection.log(ERC20Events::Transfer {1815 from: H160::default(),1816 to: *owner.as_eth(),1817 value: value.into(),1818 })?;1819 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1820 Ok(())1821 }18221823 fn add_refungible_item(1824 collection: &CollectionHandle<T>,1825 item: ReFungibleItemType<T::CrossAccountId>,1826 ) -> DispatchResult {1827 let collection_id = collection.id;18281829 let current_index = <ItemListIndex>::get(collection_id)1830 .checked_add(1)1831 .ok_or(Error::<T>::NumOverflow)?;1832 let itemcopy = item.clone();18331834 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1835 let item_owner = item.owner.first().expect("only one owner is defined");18361837 let value = item_owner.fraction;1838 let owner = item_owner.owner.clone();18391840 Self::add_token_index(collection, current_index, &owner)?;18411842 <ItemListIndex>::insert(collection_id, current_index);1843 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18441845 1846 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1847 .checked_add(value)1848 .ok_or(Error::<T>::NumOverflow)?;1849 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18501851 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1852 Ok(())1853 }18541855 fn add_nft_item(1856 collection: &CollectionHandle<T>,1857 item: NftItemType<T::CrossAccountId>,1858 ) -> DispatchResult {1859 let collection_id = collection.id;18601861 let current_index = <ItemListIndex>::get(collection_id)1862 .checked_add(1)1863 .ok_or(Error::<T>::NumOverflow)?;18641865 let item_owner = item.owner.clone();1866 Self::add_token_index(collection, current_index, &item.owner)?;18671868 <ItemListIndex>::insert(collection_id, current_index);1869 <NftItemList<T>>::insert(collection_id, current_index, item);18701871 1872 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1873 .checked_add(1)1874 .ok_or(Error::<T>::NumOverflow)?;1875 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18761877 collection.log(ERC721Events::Transfer {1878 from: H160::default(),1879 to: *item_owner.as_eth(),1880 token_id: current_index.into(),1881 })?;1882 Self::deposit_event(RawEvent::ItemCreated(1883 collection_id,1884 current_index,1885 item_owner,1886 ));1887 Ok(())1888 }18891890 fn burn_refungible_item(1891 collection: &CollectionHandle<T>,1892 item_id: TokenId,1893 owner: &T::CrossAccountId,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 rft_balance = token1900 .owner1901 .iter()1902 .find(|&i| i.owner == *owner)1903 .ok_or(Error::<T>::TokenNotFound)?;1904 Self::remove_token_index(collection, item_id, owner)?;19051906 1907 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1908 .checked_sub(rft_balance.fraction)1909 .ok_or(Error::<T>::NumOverflow)?;1910 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19111912 1913 let index = token1914 .owner1915 .iter()1916 .position(|i| i.owner == *owner)1917 .expect("owned item is exists");1918 token.owner.remove(index);1919 let owner_count = token.owner.len();19201921 1922 if owner_count == 0 {1923 <ReFungibleItemList<T>>::remove(collection_id, item_id);1924 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1925 } else {1926 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1927 }19281929 Ok(())1930 }19311932 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1933 let collection_id = collection.id;19341935 let item =1936 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1937 Self::remove_token_index(collection, item_id, &item.owner)?;19381939 1940 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1941 .checked_sub(1)1942 .ok_or(Error::<T>::NumOverflow)?;1943 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1944 <NftItemList<T>>::remove(collection_id, item_id);1945 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19461947 collection.log(ERC721Events::Transfer {1948 from: *item.owner.as_eth(),1949 to: H160::default(),1950 token_id: item_id.into(),1951 })?;1952 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1953 Ok(())1954 }19551956 fn burn_fungible_item(1957 owner: &T::CrossAccountId,1958 collection: &CollectionHandle<T>,1959 value: u128,1960 ) -> DispatchResult {1961 let collection_id = collection.id;19621963 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1964 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19651966 1967 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1968 .checked_sub(value)1969 .ok_or(Error::<T>::NumOverflow)?;1970 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19711972 if balance.value - value > 0 {1973 balance.value -= value;1974 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1975 } else {1976 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1977 }19781979 collection.log(ERC20Events::Transfer {1980 from: *owner.as_eth(),1981 to: H160::default(),1982 value: value.into(),1983 })?;1984 Ok(())1985 }19861987 pub fn get_collection(1988 collection_id: CollectionId,1989 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1990 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1991 }19921993 fn check_owner_permissions(1994 target_collection: &CollectionHandle<T>,1995 subject: &T::AccountId,1996 ) -> DispatchResult {1997 ensure!(1998 *subject == target_collection.owner,1999 Error::<T>::NoPermission2000 );20012002 Ok(())2003 }20042005 fn is_owner_or_admin_permissions(2006 collection: &CollectionHandle<T>,2007 subject: &T::CrossAccountId,2008 ) -> Result<bool, DispatchError> {2009 collection.consume_sload()?;2010 Ok(*subject.as_sub() == collection.owner2011 || <AdminList<T>>::get(collection.id).contains(subject))2012 }20132014 fn check_owner_or_admin_permissions(2015 collection: &CollectionHandle<T>,2016 subject: &T::CrossAccountId,2017 ) -> DispatchResult {2018 ensure!(2019 Self::is_owner_or_admin_permissions(collection, subject)?,2020 Error::<T>::NoPermission2021 );20222023 Ok(())2024 }20252026 fn owned_amount(2027 subject: &T::CrossAccountId,2028 collection: &CollectionHandle<T>,2029 item_id: TokenId,2030 ) -> Result<Option<u128>, DispatchError> {2031 collection.consume_sload()?;2032 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2033 }20342035 fn owned_amount_unchecked(2036 subject: &T::CrossAccountId,2037 target_collection: &CollectionHandle<T>,2038 item_id: TokenId,2039 ) -> Option<u128> {2040 let collection_id = target_collection.id;20412042 match target_collection.mode {2043 CollectionMode::NFT => {2044 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2045 }2046 CollectionMode::Fungible(_) => {2047 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2048 }2049 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2050 .owner2051 .iter()2052 .find(|i| i.owner == *subject)2053 .map(|i| i.fraction),2054 CollectionMode::Invalid => None,2055 }2056 }20572058 fn is_item_owner(2059 subject: &T::CrossAccountId,2060 target_collection: &CollectionHandle<T>,2061 item_id: TokenId,2062 ) -> Result<bool, DispatchError> {2063 Ok(match target_collection.mode {2064 CollectionMode::Fungible(_) => true,2065 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2066 })2067 }20682069 fn check_white_list(2070 collection: &CollectionHandle<T>,2071 address: &T::CrossAccountId,2072 ) -> DispatchResult {2073 collection.consume_sload()?;2074 ensure!(2075 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2076 Error::<T>::AddresNotInWhiteList,2077 );2078 Ok(())2079 }20802081 2082 2083 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2084 let collection_id = target_collection.id;2085 let exists = match target_collection.mode {2086 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2087 CollectionMode::Fungible(_) => true,2088 CollectionMode::ReFungible => {2089 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2090 }2091 _ => false,2092 };20932094 ensure!(exists, Error::<T>::TokenNotFound);2095 Ok(())2096 }20972098 fn transfer_fungible(2099 collection: &CollectionHandle<T>,2100 value: u128,2101 owner: &T::CrossAccountId,2102 recipient: &T::CrossAccountId,2103 ) -> DispatchResult {2104 let collection_id = collection.id;21052106 collection.consume_sload()?;2107 collection.consume_sload()?;2108 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2109 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21102111 recipient_balance.value = recipient_balance2112 .value2113 .checked_add(value)2114 .ok_or(Error::<T>::NumOverflow)?;2115 balance.value = balance2116 .value2117 .checked_sub(value)2118 .ok_or(Error::<T>::TokenValueTooLow)?;21192120 2121 collection.consume_sstore()?;2122 collection.consume_sstore()?;2123 if balance.value != 0 {2124 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2125 } else {2126 <Balance<T>>::remove(collection_id, owner.as_sub());2127 }2128 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21292130 2131 collection.consume_sstore()?;2132 collection.consume_sstore()?;2133 if balance.value != 0 {2134 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2135 } else {2136 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2137 }2138 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21392140 collection.log(ERC20Events::Transfer {2141 from: *owner.as_eth(),2142 to: *recipient.as_eth(),2143 value: value.into(),2144 })?;2145 Self::deposit_event(RawEvent::Transfer(2146 collection.id,2147 1,2148 owner.clone(),2149 recipient.clone(),2150 value,2151 ));21522153 Ok(())2154 }21552156 fn transfer_refungible(2157 collection: &CollectionHandle<T>,2158 item_id: TokenId,2159 value: u128,2160 owner: T::CrossAccountId,2161 new_owner: T::CrossAccountId,2162 ) -> DispatchResult {2163 let collection_id = collection.id;2164 collection.consume_sload()?;2165 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2166 .ok_or(Error::<T>::TokenNotFound)?;21672168 let item = full_item2169 .owner2170 .iter()2171 .find(|i| i.owner == owner)2172 .ok_or(Error::<T>::TokenNotFound)?;2173 let amount = item.fraction;21742175 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21762177 collection.consume_sload()?;2178 2179 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2180 .checked_sub(value)2181 .ok_or(Error::<T>::NumOverflow)?;2182 collection.consume_sstore()?;2183 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21842185 collection.consume_sload()?;2186 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2187 .checked_add(value)2188 .ok_or(Error::<T>::NumOverflow)?;2189 collection.consume_sstore()?;2190 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21912192 let old_owner = item.owner.clone();2193 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21942195 let mut new_full_item = full_item.clone();2196 2197 if amount == value && !new_owner_has_account {2198 2199 2200 new_full_item2201 .owner2202 .iter_mut()2203 .find(|i| i.owner == owner)2204 .expect("old owner does present in refungible")2205 .owner = new_owner.clone();2206 collection.consume_sstore()?;2207 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22082209 2210 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2211 } else {2212 new_full_item2213 .owner2214 .iter_mut()2215 .find(|i| i.owner == owner)2216 .expect("old owner does present in refungible")2217 .fraction -= value;22182219 2220 if new_owner_has_account {2221 2222 new_full_item2223 .owner2224 .iter_mut()2225 .find(|i| i.owner == new_owner)2226 .expect("new owner has account")2227 .fraction += value;2228 } else {2229 2230 new_full_item.owner.push(Ownership {2231 owner: new_owner.clone(),2232 fraction: value,2233 });2234 Self::add_token_index(collection, item_id, &new_owner)?;2235 }22362237 collection.consume_sstore()?;2238 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2239 }22402241 Self::deposit_event(RawEvent::Transfer(2242 collection.id,2243 item_id,2244 owner,2245 new_owner,2246 amount,2247 ));22482249 Ok(())2250 }22512252 fn transfer_nft(2253 collection: &CollectionHandle<T>,2254 item_id: TokenId,2255 sender: T::CrossAccountId,2256 new_owner: T::CrossAccountId,2257 ) -> DispatchResult {2258 let collection_id = collection.id;2259 collection.consume_sload()?;2260 let mut item =2261 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22622263 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22642265 collection.consume_sload()?;2266 2267 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2268 .checked_sub(1)2269 .ok_or(Error::<T>::NumOverflow)?;2270 collection.consume_sstore()?;2271 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22722273 collection.consume_sload()?;2274 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2275 .checked_add(1)2276 .ok_or(Error::<T>::NumOverflow)?;2277 collection.consume_sstore()?;2278 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22792280 2281 let old_owner = item.owner.clone();2282 item.owner = new_owner.clone();2283 collection.consume_sstore()?;2284 <NftItemList<T>>::insert(collection_id, item_id, item);22852286 2287 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22882289 collection.log(ERC721Events::Transfer {2290 from: *sender.as_eth(),2291 to: *new_owner.as_eth(),2292 token_id: item_id.into(),2293 })?;2294 Self::deposit_event(RawEvent::Transfer(2295 collection.id,2296 item_id,2297 sender,2298 new_owner,2299 1,2300 ));23012302 Ok(())2303 }23042305 fn set_re_fungible_variable_data(2306 collection: &CollectionHandle<T>,2307 item_id: TokenId,2308 data: Vec<u8>,2309 ) -> DispatchResult {2310 let collection_id = collection.id;2311 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2312 .ok_or(Error::<T>::TokenNotFound)?;23132314 item.variable_data = data;23152316 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23172318 Ok(())2319 }23202321 fn set_nft_variable_data(2322 collection: &CollectionHandle<T>,2323 item_id: TokenId,2324 data: Vec<u8>,2325 ) -> DispatchResult {2326 let collection_id = collection.id;2327 let mut item =2328 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23292330 item.variable_data = data;23312332 <NftItemList<T>>::insert(collection_id, item_id, item);23332334 Ok(())2335 }23362337 #[allow(dead_code)]2338 fn init_collection(item: &Collection<T>) {2339 2340 assert!(2341 item.decimal_points <= MAX_DECIMAL_POINTS,2342 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2343 );2344 assert!(2345 item.name.len() <= 64,2346 "Collection name can not be longer than 63 char"2347 );2348 assert!(2349 item.name.len() <= 256,2350 "Collection description can not be longer than 255 char"2351 );2352 assert!(2353 item.token_prefix.len() <= 16,2354 "Token prefix can not be longer than 15 char"2355 );23562357 2358 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23592360 CreatedCollectionCount::put(next_id);2361 }23622363 #[allow(dead_code)]2364 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2365 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23662367 Self::add_token_index(2368 &CollectionHandle::get(collection_id).unwrap(),2369 current_index,2370 &item.owner,2371 )2372 .unwrap();23732374 <ItemListIndex>::insert(collection_id, current_index);23752376 2377 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2378 .checked_add(1)2379 .unwrap();2380 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2381 }23822383 #[allow(dead_code)]2384 fn init_fungible_token(2385 collection_id: CollectionId,2386 owner: &T::CrossAccountId,2387 item: &FungibleItemType,2388 ) {2389 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23902391 Self::add_token_index(2392 &CollectionHandle::get(collection_id).unwrap(),2393 current_index,2394 owner,2395 )2396 .unwrap();23972398 <ItemListIndex>::insert(collection_id, current_index);23992400 2401 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2402 .checked_add(item.value)2403 .unwrap();2404 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2405 }24062407 #[allow(dead_code)]2408 fn init_refungible_token(2409 collection_id: CollectionId,2410 item: &ReFungibleItemType<T::CrossAccountId>,2411 ) {2412 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24132414 let value = item.owner.first().unwrap().fraction;2415 let owner = item.owner.first().unwrap().owner.clone();24162417 Self::add_token_index(2418 &CollectionHandle::get(collection_id).unwrap(),2419 current_index,2420 &owner,2421 )2422 .unwrap();24232424 <ItemListIndex>::insert(collection_id, current_index);24252426 2427 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2428 .checked_add(value)2429 .unwrap();2430 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2431 }24322433 fn add_token_index(2434 collection: &CollectionHandle<T>,2435 item_index: TokenId,2436 owner: &T::CrossAccountId,2437 ) -> DispatchResult {2438 collection.consume_sload()?;2439 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2440 if list_exists {2441 collection.consume_sload()?;2442 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24432444 2445 let account_items: u32 = list.len() as u32;2446 ensure!(2447 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2448 Error::<T>::AddressOwnershipLimitExceeded2449 );24502451 let item_contains = list.contains(&item_index.clone());24522453 if !item_contains {2454 list.push(item_index);2455 }24562457 collection.consume_sstore()?;2458 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2459 } else {2460 let itm = vec![item_index];2461 collection.consume_sstore()?;2462 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2463 }24642465 Ok(())2466 }24672468 fn remove_token_index(2469 collection: &CollectionHandle<T>,2470 item_index: TokenId,2471 owner: &T::CrossAccountId,2472 ) -> DispatchResult {2473 collection.consume_sload()?;2474 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2475 if list_exists {2476 collection.consume_sload()?;2477 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2478 let item_contains = list.contains(&item_index.clone());24792480 if item_contains {2481 list.retain(|&item| item != item_index);2482 collection.consume_sstore()?;2483 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2484 }2485 }24862487 Ok(())2488 }24892490 fn move_token_index(2491 collection: &CollectionHandle<T>,2492 item_index: TokenId,2493 old_owner: &T::CrossAccountId,2494 new_owner: &T::CrossAccountId,2495 ) -> DispatchResult {2496 Self::remove_token_index(collection, item_index, old_owner)?;2497 Self::add_token_index(collection, item_index, new_owner)?;24982499 Ok(())2500 }2501}25022503sp_api::decl_runtime_apis! {2504 pub trait NftApi {2505 2506 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2507 }2508}