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)?;11251126 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11271128 Ok(())1129 }11301131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 #[weight = <SelfWeightOf<T>>::set_schema_version()]1146 #[transactional]1147 pub fn set_schema_version(1148 origin,1149 collection_id: CollectionId,1150 version: SchemaVersion1151 ) -> DispatchResult {1152 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1153 let mut target_collection = Self::get_collection(collection_id)?;1154 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1155 target_collection.schema_version = version;1156 target_collection.save()1157 }11581159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1172 #[transactional]1173 pub fn set_offchain_schema(1174 origin,1175 collection_id: CollectionId,1176 schema: Vec<u8>1177 ) -> DispatchResult {1178 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1179 let mut target_collection = Self::get_collection(collection_id)?;1180 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11811182 1183 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11841185 target_collection.offchain_schema = schema;1186 target_collection.save()1187 }11881189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1202 #[transactional]1203 pub fn set_const_on_chain_schema (1204 origin,1205 collection_id: CollectionId,1206 schema: Vec<u8>1207 ) -> DispatchResult {1208 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1209 let mut target_collection = Self::get_collection(collection_id)?;1210 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12111212 1213 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12141215 target_collection.const_on_chain_schema = schema;1216 target_collection.save()1217 }12181219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1232 #[transactional]1233 pub fn set_variable_on_chain_schema (1234 origin,1235 collection_id: CollectionId,1236 schema: Vec<u8>1237 ) -> DispatchResult {1238 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1239 let mut target_collection = Self::get_collection(collection_id)?;1240 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12411242 1243 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12441245 target_collection.variable_on_chain_schema = schema;1246 target_collection.save()1247 }12481249 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1250 #[transactional]1251 pub fn set_collection_limits(1252 origin,1253 collection_id: u32,1254 new_limits: CollectionLimits<T::BlockNumber>,1255 ) -> DispatchResult {1256 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1257 let mut target_collection = Self::get_collection(collection_id)?;1258 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1259 let old_limits = &target_collection.limits;12601261 1262 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1263 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1264 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1265 Error::<T>::CollectionLimitBoundsExceeded);12661267 1268 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1269 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12701271 ensure!(1272 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1273 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1274 Error::<T>::OwnerPermissionsCantBeReverted,1275 );12761277 target_collection.limits = new_limits;12781279 target_collection.save()1280 }1281 }1282}12831284impl<T: Config> Module<T> {1285 pub fn create_item_internal(1286 sender: &T::CrossAccountId,1287 collection: &CollectionHandle<T>,1288 owner: &T::CrossAccountId,1289 data: CreateItemData,1290 ) -> DispatchResult {1291 ensure!(1292 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1293 Error::<T>::AddressIsZero1294 );12951296 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1297 Self::validate_create_item_args(collection, &data)?;1298 Self::create_item_no_validation(collection, owner, data)?;12991300 Ok(())1301 }13021303 pub fn transfer_internal(1304 sender: &T::CrossAccountId,1305 recipient: &T::CrossAccountId,1306 target_collection: &CollectionHandle<T>,1307 item_id: TokenId,1308 value: u128,1309 ) -> DispatchResult {1310 ensure!(1311 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1312 Error::<T>::AddressIsZero1313 );13141315 1316 Self::is_correct_transfer(target_collection, recipient)?;13171318 1319 ensure!(1320 Self::is_item_owner(sender, target_collection, item_id)?1321 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1322 Error::<T>::NoPermission1323 );13241325 if target_collection.access == AccessMode::WhiteList {1326 Self::check_white_list(target_collection, sender)?;1327 Self::check_white_list(target_collection, recipient)?;1328 }13291330 match target_collection.mode {1331 CollectionMode::NFT => Self::transfer_nft(1332 target_collection,1333 item_id,1334 sender.clone(),1335 recipient.clone(),1336 )?,1337 CollectionMode::Fungible(_) => {1338 Self::transfer_fungible(target_collection, value, sender, recipient)?1339 }1340 CollectionMode::ReFungible => Self::transfer_refungible(1341 target_collection,1342 item_id,1343 value,1344 sender.clone(),1345 recipient.clone(),1346 )?,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 _ => (),1494 };14951496 if matches!(collection.mode, CollectionMode::Fungible(_)) {1497 collection.log(ERC20Events::Approval {1498 owner: *from.as_eth(),1499 spender: *sender.as_eth(),1500 value: allowance.into(),1501 })?;1502 }15031504 Ok(())1505 }15061507 pub fn set_variable_meta_data_internal(1508 sender: &T::CrossAccountId,1509 collection: &CollectionHandle<T>,1510 item_id: TokenId,1511 data: Vec<u8>,1512 ) -> DispatchResult {1513 Self::token_exists(collection, item_id)?;15141515 ensure!(1516 CUSTOM_DATA_LIMIT >= data.len() as u32,1517 Error::<T>::TokenVariableDataLimitExceeded1518 );15191520 ensure!(1521 (Self::is_item_owner(sender, collection, item_id)?1522 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1523 || (Self::is_owner_or_admin_permissions(collection, sender)?1524 && collection.meta_update_permission == MetaUpdatePermission::Admin),1525 Error::<T>::NoPermission1526 );15271528 match collection.mode {1529 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1530 CollectionMode::ReFungible => {1531 Self::set_re_fungible_variable_data(collection, item_id, data)?1532 }1533 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1534 _ => fail!(Error::<T>::UnexpectedCollectionType),1535 };15361537 Ok(())1538 }15391540 pub fn meta_update_check(1541 sender: &T::CrossAccountId,1542 collection: &CollectionHandle<T>,1543 item_id: TokenId,1544 ) -> DispatchResult {1545 match collection.meta_update_permission {1546 MetaUpdatePermission::ItemOwner => ensure!(1547 Self::is_item_owner(sender, collection, item_id)?,1548 Error::<T>::NoPermission1549 ),1550 MetaUpdatePermission::Admin => ensure!(1551 Self::is_owner_or_admin_permissions(collection, sender)?,1552 Error::<T>::NoPermission1553 ),1554 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1555 }15561557 Ok(())1558 }15591560 pub fn get_variable_metadata(1561 collection: &CollectionHandle<T>,1562 item_id: TokenId,1563 ) -> Result<Vec<u8>, DispatchError> {1564 Ok(match collection.mode {1565 CollectionMode::NFT => {1566 <NftItemList<T>>::get(collection.id, item_id)1567 .ok_or(Error::<T>::TokenNotFound)?1568 .variable_data1569 }1570 CollectionMode::ReFungible => {1571 <ReFungibleItemList<T>>::get(collection.id, item_id)1572 .ok_or(Error::<T>::TokenNotFound)?1573 .variable_data1574 }1575 _ => fail!(Error::<T>::UnexpectedCollectionType),1576 })1577 }15781579 pub fn create_multiple_items_internal(1580 sender: &T::CrossAccountId,1581 collection: &CollectionHandle<T>,1582 owner: &T::CrossAccountId,1583 items_data: Vec<CreateItemData>,1584 ) -> DispatchResult {1585 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15861587 for data in &items_data {1588 Self::validate_create_item_args(collection, data)?;1589 }1590 for data in &items_data {1591 Self::create_item_no_validation(collection, owner, data.clone())?;1592 }15931594 Ok(())1595 }15961597 pub fn burn_item_internal(1598 sender: &T::CrossAccountId,1599 collection: &CollectionHandle<T>,1600 item_id: TokenId,1601 value: u128,1602 ) -> DispatchResult {1603 ensure!(1604 Self::is_item_owner(sender, collection, item_id)?1605 || (collection.limits.owner_can_transfer1606 && Self::is_owner_or_admin_permissions(collection, sender)?),1607 Error::<T>::NoPermission1608 );16091610 if collection.access == AccessMode::WhiteList {1611 Self::check_white_list(collection, sender)?;1612 }16131614 match collection.mode {1615 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1616 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1617 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1618 _ => (),1619 };16201621 Ok(())1622 }16231624 pub fn toggle_white_list_internal(1625 sender: &T::CrossAccountId,1626 collection: &CollectionHandle<T>,1627 address: &T::CrossAccountId,1628 whitelisted: bool,1629 ) -> DispatchResult {1630 Self::check_owner_or_admin_permissions(collection, sender)?;16311632 if whitelisted {1633 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1634 } else {1635 <WhiteList<T>>::remove(collection.id, address.as_sub());1636 }16371638 Ok(())1639 }16401641 fn is_correct_transfer(1642 collection: &CollectionHandle<T>,1643 recipient: &T::CrossAccountId,1644 ) -> DispatchResult {1645 let collection_id = collection.id;16461647 1648 collection.consume_sload()?;1649 let account_items: u32 =1650 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16511652 1653 1654 let limit = if collection.limits.account_token_ownership_limit == 01655 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1656 {1657 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1658 } else {1659 collection.limits.account_token_ownership_limit1660 };16611662 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16631664 1665 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16661667 Ok(())1668 }16691670 fn can_create_items_in_collection(1671 collection: &CollectionHandle<T>,1672 sender: &T::CrossAccountId,1673 owner: &T::CrossAccountId,1674 amount: u32,1675 ) -> DispatchResult {1676 let collection_id = collection.id;16771678 1679 let total_items: u32 = ItemListIndex::get(collection_id)1680 .checked_add(amount)1681 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1682 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1683 as u32)1684 .checked_add(amount)1685 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16861687 1688 1689 let account_token_limit = if collection.limits.account_token_ownership_limit == 01690 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1691 {1692 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1693 } else {1694 collection.limits.account_token_ownership_limit1695 };16961697 ensure!(1698 collection.limits.token_limit >= total_items,1699 Error::<T>::CollectionTokenLimitExceeded1700 );1701 ensure!(1702 account_token_limit >= account_items,1703 Error::<T>::AccountTokenLimitExceeded1704 );17051706 if !Self::is_owner_or_admin_permissions(collection, sender)? {1707 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1708 Self::check_white_list(collection, owner)?;1709 Self::check_white_list(collection, sender)?;1710 }17111712 Ok(())1713 }17141715 fn validate_create_item_args(1716 target_collection: &CollectionHandle<T>,1717 data: &CreateItemData,1718 ) -> DispatchResult {1719 match target_collection.mode {1720 CollectionMode::NFT => {1721 if !matches!(data, CreateItemData::NFT(_)) {1722 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1723 }1724 }1725 CollectionMode::Fungible(_) => {1726 if !matches!(data, CreateItemData::Fungible(_)) {1727 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1728 }1729 }1730 CollectionMode::ReFungible => {1731 if let CreateItemData::ReFungible(data) = data {1732 1733 ensure!(1734 data.pieces <= MAX_REFUNGIBLE_PIECES,1735 Error::<T>::WrongRefungiblePieces1736 );1737 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1738 } else {1739 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1740 }1741 }1742 _ => {1743 fail!(Error::<T>::UnexpectedCollectionType);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 ) -> DispatchResult {1894 let collection_id = collection.id;18951896 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1897 .ok_or(Error::<T>::TokenNotFound)?;1898 let rft_balance = token1899 .owner1900 .iter()1901 .find(|&i| i.owner == *owner)1902 .ok_or(Error::<T>::TokenNotFound)?;1903 Self::remove_token_index(collection, item_id, owner)?;19041905 1906 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1907 .checked_sub(rft_balance.fraction)1908 .ok_or(Error::<T>::NumOverflow)?;1909 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19101911 1912 let index = token1913 .owner1914 .iter()1915 .position(|i| i.owner == *owner)1916 .expect("owned item is exists");1917 token.owner.remove(index);1918 let owner_count = token.owner.len();19191920 1921 if owner_count == 0 {1922 <ReFungibleItemList<T>>::remove(collection_id, item_id);1923 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1924 } else {1925 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1926 }19271928 Ok(())1929 }19301931 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1932 let collection_id = collection.id;19331934 let item =1935 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1936 Self::remove_token_index(collection, item_id, &item.owner)?;19371938 1939 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1940 .checked_sub(1)1941 .ok_or(Error::<T>::NumOverflow)?;1942 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1943 <NftItemList<T>>::remove(collection_id, item_id);1944 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19451946 collection.log(ERC721Events::Transfer {1947 from: *item.owner.as_eth(),1948 to: H160::default(),1949 token_id: item_id.into(),1950 })?;1951 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1952 Ok(())1953 }19541955 fn burn_fungible_item(1956 owner: &T::CrossAccountId,1957 collection: &CollectionHandle<T>,1958 value: u128,1959 ) -> DispatchResult {1960 let collection_id = collection.id;19611962 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1963 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19641965 1966 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1967 .checked_sub(value)1968 .ok_or(Error::<T>::NumOverflow)?;1969 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19701971 if balance.value - value > 0 {1972 balance.value -= value;1973 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1974 } else {1975 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1976 }19771978 collection.log(ERC20Events::Transfer {1979 from: *owner.as_eth(),1980 to: H160::default(),1981 value: value.into(),1982 })?;1983 Ok(())1984 }19851986 pub fn get_collection(1987 collection_id: CollectionId,1988 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1989 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1990 }19911992 fn check_owner_permissions(1993 target_collection: &CollectionHandle<T>,1994 subject: &T::AccountId,1995 ) -> DispatchResult {1996 ensure!(1997 *subject == target_collection.owner,1998 Error::<T>::NoPermission1999 );20002001 Ok(())2002 }20032004 fn is_owner_or_admin_permissions(2005 collection: &CollectionHandle<T>,2006 subject: &T::CrossAccountId,2007 ) -> Result<bool, DispatchError> {2008 collection.consume_sload()?;2009 Ok(*subject.as_sub() == collection.owner2010 || <AdminList<T>>::get(collection.id).contains(subject))2011 }20122013 fn check_owner_or_admin_permissions(2014 collection: &CollectionHandle<T>,2015 subject: &T::CrossAccountId,2016 ) -> DispatchResult {2017 ensure!(2018 Self::is_owner_or_admin_permissions(collection, subject)?,2019 Error::<T>::NoPermission2020 );20212022 Ok(())2023 }20242025 fn owned_amount(2026 subject: &T::CrossAccountId,2027 collection: &CollectionHandle<T>,2028 item_id: TokenId,2029 ) -> Result<Option<u128>, DispatchError> {2030 collection.consume_sload()?;2031 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2032 }20332034 fn owned_amount_unchecked(2035 subject: &T::CrossAccountId,2036 target_collection: &CollectionHandle<T>,2037 item_id: TokenId,2038 ) -> Option<u128> {2039 let collection_id = target_collection.id;20402041 match target_collection.mode {2042 CollectionMode::NFT => {2043 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2044 }2045 CollectionMode::Fungible(_) => {2046 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2047 }2048 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2049 .owner2050 .iter()2051 .find(|i| i.owner == *subject)2052 .map(|i| i.fraction),2053 CollectionMode::Invalid => None,2054 }2055 }20562057 fn is_item_owner(2058 subject: &T::CrossAccountId,2059 target_collection: &CollectionHandle<T>,2060 item_id: TokenId,2061 ) -> Result<bool, DispatchError> {2062 Ok(match target_collection.mode {2063 CollectionMode::Fungible(_) => true,2064 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2065 })2066 }20672068 fn check_white_list(2069 collection: &CollectionHandle<T>,2070 address: &T::CrossAccountId,2071 ) -> DispatchResult {2072 collection.consume_sload()?;2073 ensure!(2074 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2075 Error::<T>::AddresNotInWhiteList,2076 );2077 Ok(())2078 }20792080 2081 2082 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2083 let collection_id = target_collection.id;2084 let exists = match target_collection.mode {2085 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2086 CollectionMode::Fungible(_) => true,2087 CollectionMode::ReFungible => {2088 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2089 }2090 _ => false,2091 };20922093 ensure!(exists, Error::<T>::TokenNotFound);2094 Ok(())2095 }20962097 fn transfer_fungible(2098 collection: &CollectionHandle<T>,2099 value: u128,2100 owner: &T::CrossAccountId,2101 recipient: &T::CrossAccountId,2102 ) -> DispatchResult {2103 let collection_id = collection.id;21042105 collection.consume_sload()?;2106 collection.consume_sload()?;2107 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2108 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21092110 recipient_balance.value = recipient_balance2111 .value2112 .checked_add(value)2113 .ok_or(Error::<T>::NumOverflow)?;2114 balance.value = balance2115 .value2116 .checked_sub(value)2117 .ok_or(Error::<T>::TokenValueTooLow)?;21182119 2120 collection.consume_sstore()?;2121 collection.consume_sstore()?;2122 if balance.value != 0 {2123 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2124 } else {2125 <Balance<T>>::remove(collection_id, owner.as_sub());2126 }2127 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21282129 2130 collection.consume_sstore()?;2131 collection.consume_sstore()?;2132 if balance.value != 0 {2133 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2134 } else {2135 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2136 }2137 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21382139 collection.log(ERC20Events::Transfer {2140 from: *owner.as_eth(),2141 to: *recipient.as_eth(),2142 value: value.into(),2143 })?;2144 Self::deposit_event(RawEvent::Transfer(2145 collection.id,2146 1,2147 owner.clone(),2148 recipient.clone(),2149 value,2150 ));21512152 Ok(())2153 }21542155 fn transfer_refungible(2156 collection: &CollectionHandle<T>,2157 item_id: TokenId,2158 value: u128,2159 owner: T::CrossAccountId,2160 new_owner: T::CrossAccountId,2161 ) -> DispatchResult {2162 let collection_id = collection.id;2163 collection.consume_sload()?;2164 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2165 .ok_or(Error::<T>::TokenNotFound)?;21662167 let item = full_item2168 .owner2169 .iter()2170 .find(|i| i.owner == owner)2171 .ok_or(Error::<T>::TokenNotFound)?;2172 let amount = item.fraction;21732174 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21752176 collection.consume_sload()?;2177 2178 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2179 .checked_sub(value)2180 .ok_or(Error::<T>::NumOverflow)?;2181 collection.consume_sstore()?;2182 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21832184 collection.consume_sload()?;2185 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2186 .checked_add(value)2187 .ok_or(Error::<T>::NumOverflow)?;2188 collection.consume_sstore()?;2189 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21902191 let old_owner = item.owner.clone();2192 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21932194 let mut new_full_item = full_item.clone();2195 2196 if amount == value && !new_owner_has_account {2197 2198 2199 new_full_item2200 .owner2201 .iter_mut()2202 .find(|i| i.owner == owner)2203 .expect("old owner does present in refungible")2204 .owner = new_owner.clone();2205 collection.consume_sstore()?;2206 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22072208 2209 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2210 } else {2211 new_full_item2212 .owner2213 .iter_mut()2214 .find(|i| i.owner == owner)2215 .expect("old owner does present in refungible")2216 .fraction -= value;22172218 2219 if new_owner_has_account {2220 2221 new_full_item2222 .owner2223 .iter_mut()2224 .find(|i| i.owner == new_owner)2225 .expect("new owner has account")2226 .fraction += value;2227 } else {2228 2229 new_full_item.owner.push(Ownership {2230 owner: new_owner.clone(),2231 fraction: value,2232 });2233 Self::add_token_index(collection, item_id, &new_owner)?;2234 }22352236 collection.consume_sstore()?;2237 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2238 }22392240 Self::deposit_event(RawEvent::Transfer(2241 collection.id,2242 item_id,2243 owner,2244 new_owner,2245 amount,2246 ));22472248 Ok(())2249 }22502251 fn transfer_nft(2252 collection: &CollectionHandle<T>,2253 item_id: TokenId,2254 sender: T::CrossAccountId,2255 new_owner: T::CrossAccountId,2256 ) -> DispatchResult {2257 let collection_id = collection.id;2258 collection.consume_sload()?;2259 let mut item =2260 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22612262 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22632264 collection.consume_sload()?;2265 2266 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2267 .checked_sub(1)2268 .ok_or(Error::<T>::NumOverflow)?;2269 collection.consume_sstore()?;2270 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22712272 collection.consume_sload()?;2273 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2274 .checked_add(1)2275 .ok_or(Error::<T>::NumOverflow)?;2276 collection.consume_sstore()?;2277 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22782279 2280 let old_owner = item.owner.clone();2281 item.owner = new_owner.clone();2282 collection.consume_sstore()?;2283 <NftItemList<T>>::insert(collection_id, item_id, item);22842285 2286 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22872288 collection.log(ERC721Events::Transfer {2289 from: *sender.as_eth(),2290 to: *new_owner.as_eth(),2291 token_id: item_id.into(),2292 })?;2293 Self::deposit_event(RawEvent::Transfer(2294 collection.id,2295 item_id,2296 sender,2297 new_owner,2298 1,2299 ));23002301 Ok(())2302 }23032304 fn set_re_fungible_variable_data(2305 collection: &CollectionHandle<T>,2306 item_id: TokenId,2307 data: Vec<u8>,2308 ) -> DispatchResult {2309 let collection_id = collection.id;2310 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2311 .ok_or(Error::<T>::TokenNotFound)?;23122313 item.variable_data = data;23142315 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23162317 Ok(())2318 }23192320 fn set_nft_variable_data(2321 collection: &CollectionHandle<T>,2322 item_id: TokenId,2323 data: Vec<u8>,2324 ) -> DispatchResult {2325 let collection_id = collection.id;2326 let mut item =2327 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23282329 item.variable_data = data;23302331 <NftItemList<T>>::insert(collection_id, item_id, item);23322333 Ok(())2334 }23352336 #[allow(dead_code)]2337 fn init_collection(item: &Collection<T>) {2338 2339 assert!(2340 item.decimal_points <= MAX_DECIMAL_POINTS,2341 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2342 );2343 assert!(2344 item.name.len() <= 64,2345 "Collection name can not be longer than 63 char"2346 );2347 assert!(2348 item.name.len() <= 256,2349 "Collection description can not be longer than 255 char"2350 );2351 assert!(2352 item.token_prefix.len() <= 16,2353 "Token prefix can not be longer than 15 char"2354 );23552356 2357 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23582359 CreatedCollectionCount::put(next_id);2360 }23612362 #[allow(dead_code)]2363 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2364 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23652366 Self::add_token_index(2367 &CollectionHandle::get(collection_id).unwrap(),2368 current_index,2369 &item.owner,2370 )2371 .unwrap();23722373 <ItemListIndex>::insert(collection_id, current_index);23742375 2376 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2377 .checked_add(1)2378 .unwrap();2379 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2380 }23812382 #[allow(dead_code)]2383 fn init_fungible_token(2384 collection_id: CollectionId,2385 owner: &T::CrossAccountId,2386 item: &FungibleItemType,2387 ) {2388 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23892390 Self::add_token_index(2391 &CollectionHandle::get(collection_id).unwrap(),2392 current_index,2393 owner,2394 )2395 .unwrap();23962397 <ItemListIndex>::insert(collection_id, current_index);23982399 2400 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2401 .checked_add(item.value)2402 .unwrap();2403 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2404 }24052406 #[allow(dead_code)]2407 fn init_refungible_token(2408 collection_id: CollectionId,2409 item: &ReFungibleItemType<T::CrossAccountId>,2410 ) {2411 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24122413 let value = item.owner.first().unwrap().fraction;2414 let owner = item.owner.first().unwrap().owner.clone();24152416 Self::add_token_index(2417 &CollectionHandle::get(collection_id).unwrap(),2418 current_index,2419 &owner,2420 )2421 .unwrap();24222423 <ItemListIndex>::insert(collection_id, current_index);24242425 2426 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2427 .checked_add(value)2428 .unwrap();2429 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2430 }24312432 fn add_token_index(2433 collection: &CollectionHandle<T>,2434 item_index: TokenId,2435 owner: &T::CrossAccountId,2436 ) -> DispatchResult {2437 collection.consume_sload()?;2438 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2439 if list_exists {2440 collection.consume_sload()?;2441 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24422443 2444 let account_items: u32 = list.len() as u32;2445 ensure!(2446 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2447 Error::<T>::AddressOwnershipLimitExceeded2448 );24492450 let item_contains = list.contains(&item_index.clone());24512452 if !item_contains {2453 list.push(item_index);2454 }24552456 collection.consume_sstore()?;2457 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2458 } else {2459 let itm = vec![item_index];2460 collection.consume_sstore()?;2461 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2462 }24632464 Ok(())2465 }24662467 fn remove_token_index(2468 collection: &CollectionHandle<T>,2469 item_index: TokenId,2470 owner: &T::CrossAccountId,2471 ) -> DispatchResult {2472 collection.consume_sload()?;2473 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2474 if list_exists {2475 collection.consume_sload()?;2476 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2477 let item_contains = list.contains(&item_index.clone());24782479 if item_contains {2480 list.retain(|&item| item != item_index);2481 collection.consume_sstore()?;2482 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2483 }2484 }24852486 Ok(())2487 }24882489 fn move_token_index(2490 collection: &CollectionHandle<T>,2491 item_index: TokenId,2492 old_owner: &T::CrossAccountId,2493 new_owner: &T::CrossAccountId,2494 ) -> DispatchResult {2495 Self::remove_token_index(collection, item_index, old_owner)?;2496 Self::add_token_index(collection, item_index, new_owner)?;24972498 Ok(())2499 }2500}25012502sp_api::decl_runtime_apis! {2503 pub trait NftApi {2504 2505 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2506 }2507}