123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub 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,32 transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38 traits::{39 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40 },41 transaction_validity::{42 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43 },44 FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263646566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73 Invalid,74 NFT,75 76 Fungible(DecimalPoints),77 ReFungible,78}7980impl Default for CollectionMode {81 fn default() -> Self {82 Self::Invalid83 }84}8586impl Into<u8> for CollectionMode {87 fn into(self) -> u8 {88 match self {89 CollectionMode::Invalid => 0,90 CollectionMode::NFT => 1,91 CollectionMode::Fungible(_) => 2,92 CollectionMode::ReFungible => 3,93 }94 }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100 Normal,101 WhiteList,102}103impl Default for AccessMode {104 fn default() -> Self {105 Self::Normal106 }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112 ImageURL,113 Unique,114}115impl Default for SchemaVersion {116 fn default() -> Self {117 Self::ImageURL118 }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124 pub owner: AccountId,125 pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131 132 Disabled,133 Unconfirmed(AccountId),134 135 Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139 fn sponsor(&self) -> Option<&AccountId> {140 match self {141 Self::Confirmed(sponsor) => Some(sponsor),142 _ => None,143 }144 }145146 fn pending_sponsor(&self) -> Option<&AccountId> {147 match self {148 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149 _ => None,150 }151 }152153 fn confirmed(&self) -> bool {154 matches!(self, Self::Confirmed(_))155 }156}157158impl<T> Default for SponsorshipState<T> {159 fn default() -> Self {160 Self::Disabled161 }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167 pub owner: T::AccountId,168 pub mode: CollectionMode,169 pub access: AccessMode,170 pub decimal_points: DecimalPoints,171 pub name: Vec<u16>, 172 pub description: Vec<u16>, 173 pub token_prefix: Vec<u8>, 174 pub mint_mode: bool,175 pub offchain_schema: Vec<u8>,176 pub schema_version: SchemaVersion,177 pub sponsorship: SponsorshipState<T::AccountId>,178 pub limits: CollectionLimits<T::BlockNumber>, 179 pub variable_on_chain_schema: Vec<u8>, 180 pub const_on_chain_schema: Vec<u8>, 181}182183pub struct CollectionHandle<T: Config> {184 pub id: CollectionId,185 collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189 type Target = Collection<T>;190191 fn deref(&self) -> &Self::Target {192 &self.collection193 }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197 fn deref_mut(&mut self) -> &mut Self::Target {198 &mut self.collection199 }200}201202#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205 pub owner: AccountId,206 pub const_data: Vec<u8>,207 pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213 pub value: u128,214}215216#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219 pub owner: Vec<Ownership<AccountId>>,220 pub const_data: Vec<u8>,221 pub variable_data: Vec<u8>,222}223224225226227228229230231232233234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238 pub account_token_ownership_limit: u32,239 pub sponsored_data_size: u32,240 241 242 243 pub sponsored_data_rate_limit: Option<BlockNumber>,244 pub token_limit: u32,245246 247 pub sponsor_transfer_timeout: u32,248 pub owner_can_transfer: bool,249 pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253 fn default() -> Self {254 Self { 255 account_token_ownership_limit: 10_000_000, 256 token_limit: u32::max_value(),257 sponsored_data_size: u32::MAX, 258 sponsored_data_rate_limit: None,259 sponsor_transfer_timeout: 14400,260 owner_can_transfer: true,261 owner_can_destroy: true262 }263 }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269 pub collection_numbers_limit: u32,270 pub account_token_ownership_limit: u32,271 pub collections_admins_limit: u64,272 pub custom_data_limit: u32,273274 275 pub nft_sponsor_transfer_timeout: u32,276 pub fungible_sponsor_transfer_timeout: u32,277 pub refungible_sponsor_transfer_timeout: u32,278279 280 pub offchain_schema_limit: u32,281 pub variable_on_chain_schema_limit: u32,282 pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286 fn create_collection() -> Weight;287 fn destroy_collection() -> Weight;288 fn add_to_white_list() -> Weight;289 fn remove_from_white_list() -> Weight;290 fn set_public_access_mode() -> Weight;291 fn set_mint_permission() -> Weight;292 fn change_collection_owner() -> Weight;293 fn add_collection_admin() -> Weight;294 fn remove_collection_admin() -> Weight;295 fn set_collection_sponsor() -> Weight;296 fn confirm_sponsorship() -> Weight;297 fn remove_collection_sponsor() -> Weight;298 fn create_item(s: usize) -> Weight;299 fn burn_item() -> Weight;300 fn transfer() -> Weight;301 fn approve() -> Weight;302 fn transfer_from() -> Weight;303 fn set_offchain_schema() -> Weight;304 fn set_const_on_chain_schema() -> Weight;305 fn set_variable_on_chain_schema() -> Weight;306 fn set_variable_meta_data() -> Weight;307 fn enable_contract_sponsoring() -> Weight;308 fn set_schema_version() -> Weight;309 fn set_chain_limits() -> Weight;310 fn set_contract_sponsoring_rate_limit() -> Weight;311 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312 fn toggle_contract_white_list() -> Weight;313 fn add_to_contract_white_list() -> Weight;314 fn remove_from_contract_white_list() -> Weight;315 fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321 pub const_data: Vec<u8>,322 pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328 pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334 pub const_data: Vec<u8>,335 pub variable_data: Vec<u8>,336 pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342 NFT(CreateNftData),343 Fungible(CreateFungibleData),344 ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348 pub fn len(&self) -> usize {349 let len = match self {350 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352 _ => 0353 };354 355 return len;356 }357}358359impl From<CreateNftData> for CreateItemData {360 fn from(item: CreateNftData) -> Self {361 CreateItemData::NFT(item)362 }363}364365impl From<CreateReFungibleData> for CreateItemData {366 fn from(item: CreateReFungibleData) -> Self {367 CreateItemData::ReFungible(item)368 }369}370371impl From<CreateFungibleData> for CreateItemData {372 fn from(item: CreateFungibleData) -> Self {373 CreateItemData::Fungible(item)374 }375}376377378decl_error! {379 380 pub enum Error for Module<T: Config> {381 382 TotalCollectionsLimitExceeded,383 384 CollectionDecimalPointLimitExceeded, 385 386 CollectionNameLimitExceeded, 387 388 CollectionDescriptionLimitExceeded, 389 390 CollectionTokenPrefixLimitExceeded,391 392 CollectionNotFound,393 394 TokenNotFound,395 396 AdminNotFound,397 398 NumOverflow, 399 400 AlreadyAdmin, 401 402 NoPermission,403 404 ConfirmUnsetSponsorFail,405 406 PublicMintingNotAllowed,407 408 MustBeTokenOwner,409 410 TokenValueTooLow,411 412 NftSizeLimitExceeded,413 414 ApproveNotFound,415 416 TokenValueNotEnough,417 418 ApproveRequired,419 420 AddresNotInWhiteList,421 422 CollectionAdminsLimitExceeded,423 424 AddressOwnershipLimitExceeded,425 426 EmptyArgument,427 428 TokenConstDataLimitExceeded,429 430 TokenVariableDataLimitExceeded,431 432 NotNftDataUsedToMintNftCollectionToken,433 434 NotFungibleDataUsedToMintFungibleCollectionToken,435 436 NotReFungibleDataUsedToMintReFungibleCollectionToken,437 438 UnexpectedCollectionType,439 440 CantStoreMetadataInFungibleTokens,441 442 CollectionTokenLimitExceeded,443 444 AccountTokenLimitExceeded,445 446 CollectionLimitBoundsExceeded,447 448 OwnerPermissionsCantBeReverted,449 450 SchemaDataLimitExceeded,451 452 WrongRefungiblePieces,453 454 BadCreateRefungibleCall,455 }456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461 462 type WeightInfo: WeightInfo;463464 type Currency: Currency<Self::AccountId>;465 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466 type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472473474475476477478479480481482483484485486487488489490491492493494495496decl_storage! {497 trait Store for Module<T: Config> as Nft {498499 500 501 CreatedCollectionCount: u32;502 503 ChainVersion: u64;504 505 506 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507 508509 510 pub ChainLimit get(fn chain_limit) config(): ChainLimits;511 512513 514 515 516 DestroyedCollectionCount: u32;517 518 519 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520 521522 523 524 525 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526 527 528 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529 530 531 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532 533534 535 536 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538 539 540 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;541542 543 544 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;545 546 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;547 548 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;549 550551 552 553 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;554 555556 557 558 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;559 560 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;561 562 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;563 564 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;565 566567 568 569 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;570 571 572 573 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;574 575 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;576 577 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;578 579 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;580 581 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 582 583 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 584 585 }586 add_extra_genesis {587 build(|config: &GenesisConfig<T>| {588 589 for (_num, _c) in &config.collection_id {590 <Module<T>>::init_collection(_c);591 }592593 for (_num, _c, _i) in &config.nft_item_id {594 <Module<T>>::init_nft_token(*_c, _i);595 }596597 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {598 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);599 }600601 for (_num, _c, _i) in &config.refungible_item_id {602 <Module<T>>::init_refungible_token(*_c, _i);603 }604 })605 }606}607608decl_event!(609 pub enum Event<T>610 where611 AccountId = <T as system::Config>::AccountId,612 {613 614 615 616 617 618 619 620 621 622 Created(CollectionId, u8, AccountId),623624 625 626 627 628 629 630 631 632 633 ItemCreated(CollectionId, TokenId, AccountId),634635 636 637 638 639 640 641 642 ItemDestroyed(CollectionId, TokenId),643644 645 646 647 648 649 650 651 652 653 654 655 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),656657 658 659 660 661 662 663 664 665 666 Approved(CollectionId, TokenId, AccountId, AccountId, u128),667 }668);669670decl_module! {671 pub struct Module<T: Config> for enum Call 672 where 673 origin: T::Origin674 {675 fn deposit_event() = default;676 type Error = Error<T>;677678 fn on_initialize(now: T::BlockNumber) -> Weight {679 0680 }681682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 #[weight = <T as Config>::WeightInfo::create_collection()]699 #[transactional]700 pub fn create_collection(origin,701 collection_name: Vec<u16>,702 collection_description: Vec<u16>,703 token_prefix: Vec<u8>,704 mode: CollectionMode) -> DispatchResult {705706 707 let who = ensure_signed(origin)?;708709 710 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();711 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(712 &T::TreasuryAccountId::get(),713 T::CollectionCreationPrice::get(),714 ));715 <T as Config>::Currency::settle(716 &who,717 imbalance,718 WithdrawReasons::TRANSFER,719 ExistenceRequirement::KeepAlive,720 ).map_err(|_| Error::<T>::NoPermission)?;721722 let decimal_points = match mode {723 CollectionMode::Fungible(points) => points,724 _ => 0725 };726727 let chain_limit = ChainLimit::get();728729 let created_count = CreatedCollectionCount::get();730 let destroyed_count = DestroyedCollectionCount::get();731732 733 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);734735 736 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);737 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);738 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);739 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);740741 742 let next_id = created_count743 .checked_add(1)744 .ok_or(Error::<T>::NumOverflow)?;745746 CreatedCollectionCount::put(next_id);747748 let limits = CollectionLimits {749 sponsored_data_size: chain_limit.custom_data_limit,750 ..Default::default()751 };752753 754 let new_collection = Collection {755 owner: who.clone(),756 name: collection_name,757 mode: mode.clone(),758 mint_mode: false,759 access: AccessMode::Normal,760 description: collection_description,761 decimal_points: decimal_points,762 token_prefix: token_prefix,763 offchain_schema: Vec::new(),764 schema_version: SchemaVersion::ImageURL,765 sponsorship: SponsorshipState::Disabled,766 variable_on_chain_schema: Vec::new(),767 const_on_chain_schema: Vec::new(),768 limits,769 };770771 772 <CollectionById<T>>::insert(next_id, new_collection);773774 775 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));776777 Ok(())778 }779780 781 782 783 784 785 786 787 788 789 #[weight = <T as Config>::WeightInfo::destroy_collection()]790 #[transactional]791 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {792793 let sender = ensure_signed(origin)?;794 let collection = Self::get_collection(collection_id)?;795 Self::check_owner_permissions(&collection, sender)?;796 if !collection.limits.owner_can_destroy {797 fail!(Error::<T>::NoPermission);798 }799800 <AddressTokens<T>>::remove_prefix(collection_id);801 <Allowances<T>>::remove_prefix(collection_id);802 <Balance<T>>::remove_prefix(collection_id);803 <ItemListIndex>::remove(collection_id);804 <AdminList<T>>::remove(collection_id);805 <CollectionById<T>>::remove(collection_id);806 <WhiteList<T>>::remove_prefix(collection_id);807808 <NftItemList<T>>::remove_prefix(collection_id);809 <FungibleItemList<T>>::remove_prefix(collection_id);810 <ReFungibleItemList<T>>::remove_prefix(collection_id);811812 <NftTransferBasket<T>>::remove_prefix(collection_id);813 <FungibleTransferBasket<T>>::remove_prefix(collection_id);814 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);815816 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);817818 DestroyedCollectionCount::put(DestroyedCollectionCount::get()819 .checked_add(1)820 .ok_or(Error::<T>::NumOverflow)?);821822 Ok(())823 }824825 826 827 828 829 830 831 832 833 834 835 836 837 #[weight = <T as Config>::WeightInfo::add_to_white_list()]838 #[transactional]839 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{840841 let sender = ensure_signed(origin)?;842 let collection = Self::get_collection(collection_id)?;843 Self::check_owner_or_admin_permissions(&collection, sender)?;844845 <WhiteList<T>>::insert(collection_id, address, true);846 847 Ok(())848 }849850 851 852 853 854 855 856 857 858 859 860 861 862 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]863 #[transactional]864 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{865866 let sender = ensure_signed(origin)?;867 let collection = Self::get_collection(collection_id)?;868 Self::check_owner_or_admin_permissions(&collection, sender)?;869870 <WhiteList<T>>::remove(collection_id, address);871872 Ok(())873 }874875 876 877 878 879 880 881 882 883 884 885 886 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]887 #[transactional]888 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult889 {890 let sender = ensure_signed(origin)?;891892 let mut target_collection = Self::get_collection(collection_id)?;893 Self::check_owner_permissions(&target_collection, sender)?;894 target_collection.access = mode;895 Self::save_collection(target_collection);896897 Ok(())898 }899900 901 902 903 904 905 906 907 908 909 910 911 912 913 #[weight = <T as Config>::WeightInfo::set_mint_permission()]914 #[transactional]915 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult916 {917 let sender = ensure_signed(origin)?;918919 let mut target_collection = Self::get_collection(collection_id)?;920 Self::check_owner_permissions(&target_collection, sender)?;921 target_collection.mint_mode = mint_permission;922 Self::save_collection(target_collection);923924 Ok(())925 }926927 928 929 930 931 932 933 934 935 936 937 938 #[weight = <T as Config>::WeightInfo::change_collection_owner()]939 #[transactional]940 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {941942 let sender = ensure_signed(origin)?;943 let mut target_collection = Self::get_collection(collection_id)?;944 Self::check_owner_permissions(&target_collection, sender)?;945 target_collection.owner = new_owner;946 Self::save_collection(target_collection);947948 Ok(())949 }950951 952 953 954 955 956 957 958 959 960 961 962 963 964 #[weight = <T as Config>::WeightInfo::add_collection_admin()]965 #[transactional]966 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {967968 let sender = ensure_signed(origin)?;969 let collection = Self::get_collection(collection_id)?;970 Self::check_owner_or_admin_permissions(&collection, sender)?;971 let mut admin_arr: Vec<T::AccountId> = Vec::new();972973 if <AdminList<T>>::contains_key(collection_id)974 {975 admin_arr = <AdminList<T>>::get(collection_id);976 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);977 }978979 980 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);981982 admin_arr.push(new_admin_id);983 <AdminList<T>>::insert(collection_id, admin_arr);984985 Ok(())986 }987988 989 990 991 992 993 994 995 996 997 998 999 1000 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1001 #[transactional]1002 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10031004 let sender = ensure_signed(origin)?;1005 let collection = Self::get_collection(collection_id)?;1006 Self::check_owner_or_admin_permissions(&collection, sender)?;1007 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);10081009 let mut admin_arr = <AdminList<T>>::get(collection_id);1010 admin_arr.retain(|i| *i != account_id);1011 <AdminList<T>>::insert(collection_id, admin_arr);10121013 Ok(())1014 }10151016 1017 1018 1019 1020 1021 1022 1023 1024 1025 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1026 #[transactional]1027 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10281029 let sender = ensure_signed(origin)?;1030 let mut target_collection = Self::get_collection(collection_id)?;1031 Self::check_owner_permissions(&target_collection, sender)?;10321033 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1034 Self::save_collection(target_collection);10351036 Ok(())1037 }10381039 1040 1041 1042 1043 1044 1045 1046 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1047 #[transactional]1048 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10491050 let sender = ensure_signed(origin)?;10511052 let mut target_collection = Self::get_collection(collection_id)?;1053 ensure!(1054 target_collection.sponsorship.pending_sponsor() == Some(&sender),1055 Error::<T>::ConfirmUnsetSponsorFail1056 );10571058 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1059 Self::save_collection(target_collection);10601061 Ok(())1062 }10631064 1065 1066 1067 1068 1069 1070 1071 1072 1073 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1074 #[transactional]1075 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10761077 let sender = ensure_signed(origin)?;10781079 let mut target_collection = Self::get_collection(collection_id)?;1080 Self::check_owner_permissions(&target_collection, sender)?;10811082 target_collection.sponsorship = SponsorshipState::Disabled;1083 Self::save_collection(target_collection);10841085 Ok(())1086 }10871088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 11111112 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1113 #[transactional]1114 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11151116 let sender = ensure_signed(origin)?;11171118 let target_collection = Self::get_collection(collection_id)?;11191120 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1121 Self::validate_create_item_args(&target_collection, &data)?;1122 Self::create_item_no_validation(&target_collection, owner, data)?;11231124 Ok(())1125 }11261127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1146 .map(|data| { data.len() })1147 .sum())]1148 #[transactional]1149 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11501151 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1152 let sender = ensure_signed(origin)?;11531154 let target_collection = Self::get_collection(collection_id)?;11551156 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11571158 for data in &items_data {1159 Self::validate_create_item_args(&target_collection, data)?;1160 }1161 for data in &items_data {1162 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1163 }11641165 Ok(())1166 }11671168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 #[weight = <T as Config>::WeightInfo::burn_item()]1182 #[transactional]1183 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11841185 let sender = ensure_signed(origin)?;11861187 1188 let target_collection = Self::get_collection(collection_id)?;1189 ensure!(1190 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1191 (1192 target_collection.limits.owner_can_transfer &&1193 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1194 ),1195 Error::<T>::NoPermission1196 );11971198 if target_collection.access == AccessMode::WhiteList {1199 Self::check_white_list(&target_collection, &sender)?;1200 }12011202 match target_collection.mode1203 {1204 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1205 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1206 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1207 _ => ()1208 };12091210 1211 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12121213 Ok(())1214 }12151216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 #[weight = <T as Config>::WeightInfo::transfer()]1240 #[transactional]1241 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1242 let sender = ensure_signed(origin)?;1243 let collection = Self::get_collection(collection_id)?;12441245 Self::transfer_internal(sender, recipient, &collection, item_id, value)1246 }12471248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 #[weight = <T as Config>::WeightInfo::approve()]1264 #[transactional]1265 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12661267 let sender = ensure_signed(origin)?;1268 let target_collection = Self::get_collection(collection_id)?;12691270 Self::token_exists(&target_collection, item_id, &sender)?;12711272 1273 let bypasses_limits = target_collection.limits.owner_can_transfer &&1274 Self::is_owner_or_admin_permissions(1275 &target_collection,1276 sender.clone(),1277 );12781279 let allowance_limit = if bypasses_limits {1280 None1281 } else if let Some(amount) = Self::owned_amount(1282 sender.clone(),1283 &target_collection,1284 item_id,1285 ) {1286 Some(amount)1287 } else {1288 fail!(Error::<T>::NoPermission);1289 };12901291 if target_collection.access == AccessMode::WhiteList {1292 Self::check_white_list(&target_collection, &sender)?;1293 Self::check_white_list(&target_collection, &spender)?;1294 }12951296 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1297 let mut allowance: u128 = amount;1298 if allowance_exists {1299 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1300 }1301 if let Some(limit) = allowance_limit {1302 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1303 }1304 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13051306 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1307 Ok(())1308 }1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 #[weight = <T as Config>::WeightInfo::transfer_from()]1330 #[transactional]1331 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13321333 let sender = ensure_signed(origin)?;1334 let target_collection = Self::get_collection(collection_id)?;13351336 let mut appoved_transfer = false;13371338 1339 let mut approval: u128 = 0;1340 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1341 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1342 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1343 appoved_transfer = true;1344 }13451346 1347 Self::is_correct_transfer(&target_collection, &recipient)?;13481349 1350 ensure!(1351 appoved_transfer || 1352 (1353 target_collection.limits.owner_can_transfer &&1354 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1355 ),1356 Error::<T>::NoPermission1357 );13581359 if target_collection.access == AccessMode::WhiteList {1360 Self::check_white_list(&target_collection, &sender)?;1361 Self::check_white_list(&target_collection, &recipient)?;1362 }13631364 1365 if approval.saturating_sub(value) > 0 {1366 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1367 }1368 else {1369 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1370 }13711372 match target_collection.mode1373 {1374 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1375 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1376 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1377 _ => ()1378 };13791380 Ok(())1381 }13821383 1384 13851386 1387 1388 1389 13901391 13921393 13941395 1396 13971398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1411 #[transactional]1412 pub fn set_variable_meta_data (1413 origin,1414 collection_id: CollectionId,1415 item_id: TokenId,1416 data: Vec<u8>1417 ) -> DispatchResult {1418 let sender = ensure_signed(origin)?;1419 1420 let target_collection = Self::get_collection(collection_id)?;1421 Self::token_exists(&target_collection, item_id, &sender)?;14221423 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14241425 1426 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1427 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1428 Error::<T>::NoPermission);14291430 match target_collection.mode1431 {1432 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1433 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1434 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1435 _ => fail!(Error::<T>::UnexpectedCollectionType)1436 };14371438 Ok(())1439 }1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 #[weight = <T as Config>::WeightInfo::set_schema_version()]1456 #[transactional]1457 pub fn set_schema_version(1458 origin,1459 collection_id: CollectionId,1460 version: SchemaVersion1461 ) -> DispatchResult {1462 let sender = ensure_signed(origin)?;1463 let mut target_collection = Self::get_collection(collection_id)?;1464 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1465 target_collection.schema_version = version;1466 Self::save_collection(target_collection);14671468 Ok(())1469 }14701471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1484 #[transactional]1485 pub fn set_offchain_schema(1486 origin,1487 collection_id: CollectionId,1488 schema: Vec<u8>1489 ) -> DispatchResult {1490 let sender = ensure_signed(origin)?;1491 let mut target_collection = Self::get_collection(collection_id)?;1492 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14931494 1495 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14961497 target_collection.offchain_schema = schema;1498 Self::save_collection(target_collection);14991500 Ok(())1501 }15021503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1516 #[transactional]1517 pub fn set_const_on_chain_schema (1518 origin,1519 collection_id: CollectionId,1520 schema: Vec<u8>1521 ) -> DispatchResult {1522 let sender = ensure_signed(origin)?;1523 let mut target_collection = Self::get_collection(collection_id)?;1524 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15251526 1527 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15281529 target_collection.const_on_chain_schema = schema;1530 Self::save_collection(target_collection);15311532 Ok(())1533 }15341535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1548 #[transactional]1549 pub fn set_variable_on_chain_schema (1550 origin,1551 collection_id: CollectionId,1552 schema: Vec<u8>1553 ) -> DispatchResult {1554 let sender = ensure_signed(origin)?;1555 let mut target_collection = Self::get_collection(collection_id)?;1556 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15571558 1559 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15601561 target_collection.variable_on_chain_schema = schema;1562 Self::save_collection(target_collection);15631564 Ok(())1565 }15661567 1568 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1569 #[transactional]1570 pub fn set_chain_limits(1571 origin,1572 limits: ChainLimits1573 ) -> DispatchResult {15741575 #[cfg(not(feature = "runtime-benchmarks"))]1576 ensure_root(origin)?;15771578 <ChainLimit>::put(limits);1579 Ok(())1580 }15811582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1594 #[transactional]1595 pub fn enable_contract_sponsoring(1596 origin,1597 contract_address: T::AccountId,1598 enable: bool1599 ) -> DispatchResult {16001601 let sender = ensure_signed(origin)?;16021603 #[cfg(feature = "runtime-benchmarks")]1604 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16051606 Self::ensure_contract_owned(sender, &contract_address)?;16071608 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1609 Ok(())1610 }16111612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1630 #[transactional]1631 pub fn set_contract_sponsoring_rate_limit(1632 origin,1633 contract_address: T::AccountId,1634 rate_limit: T::BlockNumber1635 ) -> DispatchResult {1636 let sender = ensure_signed(origin)?;16371638 #[cfg(feature = "runtime-benchmarks")]1639 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16401641 Self::ensure_contract_owned(sender, &contract_address)?;1642 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1643 Ok(())1644 }16451646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1658 #[transactional]1659 pub fn toggle_contract_white_list(1660 origin,1661 contract_address: T::AccountId,1662 enable: bool1663 ) -> DispatchResult {1664 let sender = ensure_signed(origin)?;16651666 #[cfg(feature = "runtime-benchmarks")]1667 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16681669 Self::ensure_contract_owned(sender, &contract_address)?;1670 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1671 Ok(())1672 }1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1686 #[transactional]1687 pub fn add_to_contract_white_list(1688 origin,1689 contract_address: T::AccountId,1690 account_address: T::AccountId1691 ) -> DispatchResult {1692 let sender = ensure_signed(origin)?;16931694 #[cfg(feature = "runtime-benchmarks")]1695 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1696 1697 Self::ensure_contract_owned(sender, &contract_address)?; 1698 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1699 Ok(())1700 }17011702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1714 #[transactional]1715 pub fn remove_from_contract_white_list(1716 origin,1717 contract_address: T::AccountId,1718 account_address: T::AccountId1719 ) -> DispatchResult {1720 let sender = ensure_signed(origin)?;17211722 #[cfg(feature = "runtime-benchmarks")]1723 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17241725 Self::ensure_contract_owned(sender, &contract_address)?;1726 <ContractWhiteList<T>>::remove(contract_address, account_address);1727 Ok(())1728 }17291730 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1731 #[transactional]1732 pub fn set_collection_limits(1733 origin,1734 collection_id: u32,1735 new_limits: CollectionLimits<T::BlockNumber>,1736 ) -> DispatchResult {1737 let sender = ensure_signed(origin)?;1738 let mut target_collection = Self::get_collection(collection_id)?;1739 Self::check_owner_permissions(&target_collection, sender.clone())?;1740 let old_limits = &target_collection.limits;1741 let chain_limits = ChainLimit::get();17421743 1744 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1745 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1746 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1747 Error::<T>::CollectionLimitBoundsExceeded);17481749 1750 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1751 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17521753 ensure!(1754 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1755 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1756 Error::<T>::OwnerPermissionsCantBeReverted,1757 );17581759 target_collection.limits = new_limits;1760 Self::save_collection(target_collection);17611762 Ok(())1763 } 1764 }1765}17661767impl<T: Config> Module<T> {17681769 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1770 1771 Self::is_correct_transfer(target_collection, &recipient)?;17721773 1774 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1775 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1776 Error::<T>::NoPermission);17771778 if target_collection.access == AccessMode::WhiteList {1779 Self::check_white_list(target_collection, &sender)?;1780 Self::check_white_list(target_collection, &recipient)?;1781 }17821783 match target_collection.mode1784 {1785 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1786 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1787 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1788 _ => ()1789 };17901791 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17921793 Ok(())1794 }179517961797 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1798 let collection_id = collection.id;17991800 1801 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1802 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1803 1804 Ok(())1805 }18061807 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1808 let collection_id = collection.id;18091810 1811 let total_items: u32 = ItemListIndex::get(collection_id)1812 .checked_add(amount)1813 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1814 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1815 .checked_add(amount)1816 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1817 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1818 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18191820 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1821 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1822 Self::check_white_list(collection, owner)?;1823 Self::check_white_list(collection, sender)?;1824 }18251826 Ok(())1827 }18281829 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1830 match target_collection.mode1831 {1832 CollectionMode::NFT => {1833 if let CreateItemData::NFT(data) = data {1834 1835 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1836 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1837 } else {1838 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1839 }1840 },1841 CollectionMode::Fungible(_) => {1842 if let CreateItemData::Fungible(_) = data {1843 } else {1844 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1845 }1846 },1847 CollectionMode::ReFungible => {1848 if let CreateItemData::ReFungible(data) = data {18491850 1851 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1852 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18531854 1855 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1856 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1857 } else {1858 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1859 }1860 },1861 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1862 };18631864 Ok(())1865 }18661867 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1868 match data1869 {1870 CreateItemData::NFT(data) => {1871 let item = NftItemType {1872 owner: owner.clone(),1873 const_data: data.const_data,1874 variable_data: data.variable_data1875 };18761877 Self::add_nft_item(collection, item)?;1878 },1879 CreateItemData::Fungible(data) => {1880 Self::add_fungible_item(collection, &owner, data.value)?;1881 },1882 CreateItemData::ReFungible(data) => {1883 let mut owner_list = Vec::new();1884 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18851886 let item = ReFungibleItemType {1887 owner: owner_list,1888 const_data: data.const_data,1889 variable_data: data.variable_data1890 };18911892 Self::add_refungible_item(collection, item)?;1893 }1894 };18951896 Ok(())1897 }18981899 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1900 let collection_id = collection.id;19011902 1903 let mut balance: u128 = 0;1904 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1905 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1906 } 19071908 1909 let item = FungibleItemType {1910 value: balance + value1911 };1912 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19131914 1915 let new_balance = <Balance<T>>::get(collection_id, owner)1916 .checked_add(value)1917 .ok_or(Error::<T>::NumOverflow)?;1918 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19191920 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1921 Ok(())1922 }19231924 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1925 let collection_id = collection.id;19261927 let current_index = <ItemListIndex>::get(collection_id)1928 .checked_add(1)1929 .ok_or(Error::<T>::NumOverflow)?;1930 let itemcopy = item.clone();19311932 ensure!(1933 item.owner.len() == 1,1934 Error::<T>::BadCreateRefungibleCall,1935 );1936 let item_owner = item.owner.first().expect("only one owner is defined");19371938 let value = item_owner.fraction;1939 let owner = item_owner.owner.clone();19401941 Self::add_token_index(collection_id, current_index, &owner)?;19421943 <ItemListIndex>::insert(collection_id, current_index);1944 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19451946 1947 let new_balance = <Balance<T>>::get(collection_id, &owner)1948 .checked_add(value)1949 .ok_or(Error::<T>::NumOverflow)?;1950 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19511952 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1953 Ok(())1954 }19551956 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1957 let collection_id = collection.id;19581959 let current_index = <ItemListIndex>::get(collection_id)1960 .checked_add(1)1961 .ok_or(Error::<T>::NumOverflow)?;19621963 let item_owner = item.owner.clone();1964 Self::add_token_index(collection_id, current_index, &item.owner)?;19651966 <ItemListIndex>::insert(collection_id, current_index);1967 <NftItemList<T>>::insert(collection_id, current_index, item);19681969 1970 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1971 .checked_add(1)1972 .ok_or(Error::<T>::NumOverflow)?;1973 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19741975 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1976 Ok(())1977 }19781979 fn burn_refungible_item(1980 collection: &CollectionHandle<T>,1981 item_id: TokenId,1982 owner: &T::AccountId,1983 ) -> DispatchResult {1984 let collection_id = collection.id;19851986 ensure!(1987 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1988 Error::<T>::TokenNotFound1989 );1990 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1991 let rft_balance = token1992 .owner1993 .iter()1994 .find(|&i| i.owner == *owner)1995 .ok_or(Error::<T>::TokenNotFound)?;1996 Self::remove_token_index(collection_id, item_id, owner)?;19971998 1999 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2000 .checked_sub(rft_balance.fraction)2001 .ok_or(Error::<T>::NumOverflow)?;2002 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20032004 2005 let index = token2006 .owner2007 .iter()2008 .position(|i| i.owner == *owner)2009 .expect("owned item is exists");2010 token.owner.remove(index);2011 let owner_count = token.owner.len();20122013 2014 if owner_count == 0 {2015 <ReFungibleItemList<T>>::remove(collection_id, item_id);2016 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2017 }2018 else {2019 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2020 }20212022 Ok(())2023 }20242025 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2026 let collection_id = collection.id;20272028 ensure!(2029 <NftItemList<T>>::contains_key(collection_id, item_id),2030 Error::<T>::TokenNotFound2031 );2032 let item = <NftItemList<T>>::get(collection_id, item_id);2033 Self::remove_token_index(collection_id, item_id, &item.owner)?;20342035 2036 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2037 .checked_sub(1)2038 .ok_or(Error::<T>::NumOverflow)?;2039 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2040 <NftItemList<T>>::remove(collection_id, item_id);2041 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20422043 Ok(())2044 }20452046 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2047 let collection_id = collection.id;20482049 ensure!(2050 <FungibleItemList<T>>::contains_key(collection_id, owner),2051 Error::<T>::TokenNotFound2052 );2053 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2054 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20552056 2057 let new_balance = <Balance<T>>::get(collection_id, owner)2058 .checked_sub(value)2059 .ok_or(Error::<T>::NumOverflow)?;2060 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20612062 if balance.value - value > 0 {2063 balance.value -= value;2064 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2065 }2066 else {2067 <FungibleItemList<T>>::remove(collection_id, owner);2068 }20692070 Ok(())2071 }20722073 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2074 Ok(<CollectionById<T>>::get(collection_id)2075 .map(|collection| CollectionHandle {2076 id: collection_id,2077 collection2078 })2079 .ok_or(Error::<T>::CollectionNotFound)?)2080 }20812082 fn save_collection(collection: CollectionHandle<T>) {2083 <CollectionById<T>>::insert(collection.id, collection.collection);2084 }20852086 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2087 ensure!(2088 subject == target_collection.owner,2089 Error::<T>::NoPermission2090 );20912092 Ok(())2093 }20942095 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2096 let mut result: bool = subject == collection.owner;2097 let exists = <AdminList<T>>::contains_key(collection.id);20982099 if !result & exists {2100 if <AdminList<T>>::get(collection.id).contains(&subject) {2101 result = true2102 }2103 }21042105 result2106 }21072108 fn check_owner_or_admin_permissions(2109 collection: &CollectionHandle<T>,2110 subject: T::AccountId,2111 ) -> DispatchResult {2112 let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21132114 ensure!(2115 result,2116 Error::<T>::NoPermission2117 );2118 Ok(())2119 }21202121 fn owned_amount(2122 subject: T::AccountId,2123 target_collection: &CollectionHandle<T>,2124 item_id: TokenId,2125 ) -> Option<u128> {2126 let collection_id = target_collection.id;21272128 match target_collection.mode {2129 CollectionMode::NFT => {2130 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2131 return Some(1)2132 }2133 None2134 },2135 CollectionMode::Fungible(_) => {2136 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2137 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2138 .value);2139 }2140 None2141 },2142 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2143 .owner2144 .iter()2145 .find(|i| i.owner == subject)2146 .map(|i| i.fraction),2147 CollectionMode::Invalid => None,2148 }2149 }21502151 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2152 let collection_id = target_collection.id;21532154 match target_collection.mode {2155 CollectionMode::NFT => {2156 <NftItemList<T>>::get(collection_id, item_id).owner == subject2157 }2158 CollectionMode::Fungible(_) => {2159 <FungibleItemList<T>>::contains_key(collection_id, &subject)2160 }2161 CollectionMode::ReFungible => {2162 <ReFungibleItemList<T>>::get(collection_id, item_id)2163 .owner2164 .iter()2165 .any(|i| i.owner == subject)2166 }2167 CollectionMode::Invalid => false,2168 }2169 }21702171 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2172 let collection_id = collection.id;21732174 let mes = Error::<T>::AddresNotInWhiteList;2175 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21762177 Ok(())2178 }21792180 2181 2182 fn token_exists(2183 target_collection: &CollectionHandle<T>,2184 item_id: TokenId,2185 owner: &T::AccountId2186 ) -> DispatchResult {2187 let collection_id = target_collection.id;2188 let exists = match target_collection.mode2189 {2190 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2191 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2192 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2193 _ => false2194 };21952196 ensure!(exists == true, Error::<T>::TokenNotFound);2197 Ok(())2198 }21992200 fn transfer_fungible(2201 collection: &CollectionHandle<T>,2202 value: u128,2203 owner: &T::AccountId,2204 recipient: &T::AccountId,2205 ) -> DispatchResult {2206 let collection_id = collection.id;2207 Self::token_exists(&collection, 0, owner)?;22082209 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2210 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22112212 2213 Self::add_fungible_item(collection, recipient, value)?;22142215 2216 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22172218 2219 if balance.value == value {2220 <FungibleItemList<T>>::remove(collection_id, owner);2221 }2222 else {2223 balance.value -= value;2224 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2225 }22262227 Ok(())2228 }22292230 fn transfer_refungible(2231 collection: &CollectionHandle<T>,2232 item_id: TokenId,2233 value: u128,2234 owner: T::AccountId,2235 new_owner: T::AccountId,2236 ) -> DispatchResult {2237 let collection_id = collection.id;2238 Self::token_exists(collection, item_id, &owner)?;22392240 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2241 let item = full_item2242 .owner2243 .iter()2244 .filter(|i| i.owner == owner)2245 .next()2246 .ok_or(Error::<T>::TokenNotFound)?;2247 let amount = item.fraction;22482249 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22502251 2252 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2253 .checked_sub(value)2254 .ok_or(Error::<T>::NumOverflow)?;2255 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22562257 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2258 .checked_add(value)2259 .ok_or(Error::<T>::NumOverflow)?;2260 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22612262 let old_owner = item.owner.clone();2263 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22642265 2266 if amount == value && !new_owner_has_account {2267 2268 2269 let mut new_full_item = full_item.clone();2270 new_full_item2271 .owner2272 .iter_mut()2273 .find(|i| i.owner == owner)2274 .expect("old owner does present in refungible")2275 .owner = new_owner.clone();2276 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22772278 2279 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2280 } else {2281 let mut new_full_item = full_item.clone();2282 new_full_item2283 .owner2284 .iter_mut()2285 .find(|i| i.owner == owner)2286 .expect("old owner does present in refungible")2287 .fraction -= value;22882289 2290 if new_owner_has_account {2291 2292 new_full_item2293 .owner2294 .iter_mut()2295 .find(|i| i.owner == new_owner)2296 .expect("new owner has account")2297 .fraction += value;2298 } else {2299 2300 new_full_item.owner.push(Ownership {2301 owner: new_owner.clone(),2302 fraction: value,2303 });2304 Self::add_token_index(collection_id, item_id, &new_owner)?;2305 }23062307 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2308 }23092310 Ok(())2311 }23122313 fn transfer_nft(2314 collection: &CollectionHandle<T>,2315 item_id: TokenId,2316 sender: T::AccountId,2317 new_owner: T::AccountId,2318 ) -> DispatchResult {2319 let collection_id = collection.id;2320 Self::token_exists(&collection, item_id, &sender)?;23212322 let mut item = <NftItemList<T>>::get(collection_id, item_id);23232324 ensure!(2325 sender == item.owner,2326 Error::<T>::MustBeTokenOwner2327 );23282329 2330 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2331 .checked_sub(1)2332 .ok_or(Error::<T>::NumOverflow)?;2333 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23342335 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2336 .checked_add(1)2337 .ok_or(Error::<T>::NumOverflow)?;2338 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23392340 2341 let old_owner = item.owner.clone();2342 item.owner = new_owner.clone();2343 <NftItemList<T>>::insert(collection_id, item_id, item);23442345 2346 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23472348 Ok(())2349 }2350 2351 fn set_re_fungible_variable_data(2352 collection: &CollectionHandle<T>,2353 item_id: TokenId,2354 data: Vec<u8>2355 ) -> DispatchResult {2356 let collection_id = collection.id;2357 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23582359 item.variable_data = data;23602361 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23622363 Ok(())2364 }23652366 fn set_nft_variable_data(2367 collection: &CollectionHandle<T>,2368 item_id: TokenId,2369 data: Vec<u8>2370 ) -> DispatchResult {2371 let collection_id = collection.id;2372 let mut item = <NftItemList<T>>::get(collection_id, item_id);2373 2374 item.variable_data = data;23752376 <NftItemList<T>>::insert(collection_id, item_id, item);2377 2378 Ok(())2379 }23802381 fn init_collection(item: &Collection<T>) {2382 2383 assert!(2384 item.decimal_points <= MAX_DECIMAL_POINTS,2385 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2386 );2387 assert!(2388 item.name.len() <= 64,2389 "Collection name can not be longer than 63 char"2390 );2391 assert!(2392 item.name.len() <= 256,2393 "Collection description can not be longer than 255 char"2394 );2395 assert!(2396 item.token_prefix.len() <= 16,2397 "Token prefix can not be longer than 15 char"2398 );23992400 2401 let next_id = CreatedCollectionCount::get()2402 .checked_add(1)2403 .unwrap();24042405 CreatedCollectionCount::put(next_id);2406 }24072408 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2409 let current_index = <ItemListIndex>::get(collection_id)2410 .checked_add(1)2411 .unwrap();24122413 let item_owner = item.owner.clone();2414 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24152416 <ItemListIndex>::insert(collection_id, current_index);24172418 2419 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2420 .checked_add(1)2421 .unwrap();2422 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2423 }24242425 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2426 let current_index = <ItemListIndex>::get(collection_id)2427 .checked_add(1)2428 .unwrap();24292430 Self::add_token_index(collection_id, current_index, owner).unwrap();24312432 <ItemListIndex>::insert(collection_id, current_index);24332434 2435 let new_balance = <Balance<T>>::get(collection_id, owner)2436 .checked_add(item.value)2437 .unwrap();2438 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2439 }24402441 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2442 let current_index = <ItemListIndex>::get(collection_id)2443 .checked_add(1)2444 .unwrap();24452446 let value = item.owner.first().unwrap().fraction;2447 let owner = item.owner.first().unwrap().owner.clone();24482449 Self::add_token_index(collection_id, current_index, &owner).unwrap();24502451 <ItemListIndex>::insert(collection_id, current_index);24522453 2454 let new_balance = <Balance<T>>::get(collection_id, &owner)2455 .checked_add(value)2456 .unwrap();2457 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2458 }24592460 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2461 2462 if <AccountItemCount<T>>::contains_key(owner) {24632464 2465 let count = <AccountItemCount<T>>::get(owner);2466 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24672468 <AccountItemCount<T>>::insert(owner.clone(), count2469 .checked_add(1)2470 .ok_or(Error::<T>::NumOverflow)?);2471 }2472 else {2473 <AccountItemCount<T>>::insert(owner.clone(), 1);2474 }24752476 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2477 if list_exists {2478 let mut list = <AddressTokens<T>>::get(collection_id, owner);2479 let item_contains = list.contains(&item_index.clone());24802481 if !item_contains {2482 list.push(item_index.clone());2483 }24842485 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2486 } else {2487 let mut itm = Vec::new();2488 itm.push(item_index.clone());2489 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2490 }24912492 Ok(())2493 }24942495 fn remove_token_index(2496 collection_id: CollectionId,2497 item_index: TokenId,2498 owner: &T::AccountId,2499 ) -> DispatchResult {25002501 2502 <AccountItemCount<T>>::insert(owner.clone(), 2503 <AccountItemCount<T>>::get(owner)2504 .checked_sub(1)2505 .ok_or(Error::<T>::NumOverflow)?);250625072508 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2509 if list_exists {2510 let mut list = <AddressTokens<T>>::get(collection_id, owner);2511 let item_contains = list.contains(&item_index.clone());25122513 if item_contains {2514 list.retain(|&item| item != item_index);2515 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2516 }2517 }25182519 Ok(())2520 }25212522 fn move_token_index(2523 collection_id: CollectionId,2524 item_index: TokenId,2525 old_owner: &T::AccountId,2526 new_owner: &T::AccountId,2527 ) -> DispatchResult {2528 Self::remove_token_index(collection_id, item_index, old_owner)?;2529 Self::add_token_index(collection_id, item_index, new_owner)?;25302531 Ok(())2532 }2533 2534 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2535 if <ContractOwner<T>>::contains_key(contract.clone()) {2536 let owner = <ContractOwner<T>>::get(contract);2537 ensure!(account == owner, Error::<T>::NoPermission);2538 } else {2539 fail!(Error::<T>::NoPermission);2540 }25412542 Ok(())2543 }2544}2545254625472548254925502551pub type Multiplier = FixedU128;25522553type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2554255525562557#[derive(Encode, Decode, Clone, Eq, PartialEq)]2558pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25592560impl<T: Config + Send + Sync> sp_std::fmt::Debug 2561 for ChargeTransactionPayment<T>2562{2563 #[cfg(feature = "std")]2564 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2565 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2566 }2567 #[cfg(not(feature = "std"))]2568 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2569 Ok(())2570 }2571}25722573impl<T: Config> ChargeTransactionPayment<T>2574where2575 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2576 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2577 T::AccountId: AsRef<[u8]>,2578 T::AccountId: UncheckedFrom<T::Hash>,2579{2580 fn traditional_fee(2581 len: usize,2582 info: &DispatchInfoOf<T::Call>,2583 tip: BalanceOf<T>,2584 ) -> BalanceOf<T>2585 where2586 T::Call: Dispatchable<Info = DispatchInfo>,2587 {2588 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2589 }25902591 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2592 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2593 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2594 let len_saturation = max_block_length as u64 / (len as u64).max(1);2595 let coefficient: BalanceOf<T> = weight_saturation2596 .min(len_saturation)2597 .saturated_into::<BalanceOf<T>>();2598 final_fee2599 .saturating_mul(coefficient)2600 .saturated_into::<TransactionPriority>()2601 }26022603 fn withdraw_fee(2604 &self,2605 who: &T::AccountId,2606 call: &T::Call,2607 info: &DispatchInfoOf<T::Call>,2608 len: usize,2609 ) -> Result<2610 (2611 BalanceOf<T>,2612 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2613 ),2614 TransactionValidityError,2615 > {2616 let tip = self.0;26172618 let fee = Self::traditional_fee(len, info, tip);26192620 2621 if fee.is_zero() {2622 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2623 .map(|i| (fee, i));2624 }26252626 2627 2628 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2629 Some(Call::create_item(collection_id, _owner, _properties)) => {2630 let collection = <CollectionById<T>>::get(collection_id)?;26312632 2633 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26342635 let limit = collection.limits.sponsor_transfer_timeout;2636 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2637 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2638 let limit_time = last_tx_block + limit.into();2639 if block_number <= limit_time {2640 return None;2641 }2642 }2643 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26442645 2646 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2647 collection.sponsorship.sponsor()2648 .cloned()2649 } else {2650 None2651 }2652 }2653 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2654 let collection = <CollectionById<T>>::get(collection_id)?;2655 2656 let mut sponsor_transfer = false;2657 if collection.sponsorship.confirmed() {26582659 let collection_limits = collection.limits;2660 let collection_mode = collection.mode;2661 2662 2663 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2664 sponsor_transfer = match collection_mode {2665 CollectionMode::NFT => {2666 2667 2668 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2669 collection_limits.sponsor_transfer_timeout2670 } else {2671 ChainLimit::get().nft_sponsor_transfer_timeout2672 };2673 2674 let mut sponsored = true;2675 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2676 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2677 let limit_time = last_tx_block + limit.into();2678 if block_number <= limit_time {2679 sponsored = false;2680 }2681 }2682 if sponsored {2683 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2684 }26852686 sponsored2687 }2688 CollectionMode::Fungible(_) => {2689 2690 2691 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2692 collection_limits.sponsor_transfer_timeout2693 } else {2694 ChainLimit::get().fungible_sponsor_transfer_timeout2695 };2696 2697 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2698 let mut sponsored = true;2699 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2700 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2701 let limit_time = last_tx_block + limit.into();2702 if block_number <= limit_time {2703 sponsored = false;2704 }2705 }2706 if sponsored {2707 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2708 }27092710 sponsored2711 }2712 CollectionMode::ReFungible => {2713 2714 2715 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2716 collection_limits.sponsor_transfer_timeout2717 } else {2718 ChainLimit::get().refungible_sponsor_transfer_timeout2719 };2720 2721 let mut sponsored = true;2722 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2723 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2724 let limit_time = last_tx_block + limit.into();2725 if block_number <= limit_time {2726 sponsored = false;2727 }2728 }2729 if sponsored {2730 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2731 }27322733 sponsored2734 }2735 _ => {2736 false2737 },2738 };2739 }27402741 if !sponsor_transfer {2742 None2743 } else {2744 collection.sponsorship.sponsor()2745 .cloned()2746 }2747 }27482749 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2750 let mut sponsor_metadata_changes = false;27512752 let collection = <CollectionById<T>>::get(collection_id)?;27532754 if2755 collection.sponsorship.confirmed() &&2756 2757 2758 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2759 data.len() <= collection.limits.sponsored_data_size as usize2760 {2761 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2762 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27632764 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2765 .map(|last_block| block_number - last_block > rate_limit)2766 .unwrap_or(true) 2767 {2768 sponsor_metadata_changes = true;2769 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2770 }2771 }2772 }27732774 if !sponsor_metadata_changes {2775 None2776 } else {2777 collection.sponsorship.sponsor().cloned()2778 }2779 }27802781 _ => None,2782 })();27832784 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2785 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27862787 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27882789 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2790 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2791 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2792 2793 if !owned_contract && white_list_enabled {2794 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2795 return Err(InvalidTransaction::Call.into());2796 }2797 }2798 },2799 _ => {},2800 }28012802 2803 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28042805 2806 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28072808 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2809 &who,2810 code_hash,2811 salt,2812 );2813 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28142815 None2816 },28172818 2819 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28202821 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2822 &who,2823 &T::Hashing::hash(&_code),2824 _salt,2825 );28262827 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28282829 None2830 }28312832 2833 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28342835 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28362837 let mut sponsor_transfer = false;2838 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2839 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2840 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2841 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2842 let limit_time = last_tx_block + rate_limit;28432844 if block_number >= limit_time {2845 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2846 sponsor_transfer = true;2847 }2848 } else {2849 sponsor_transfer = false;2850 }2851 2852 if sponsor_transfer {2853 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2854 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2855 return Some(called_contract);2856 }2857 }2858 }28592860 None2861 },28622863 _ => None,2864 });28652866 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28672868 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2869 .map(|i| (fee, i))2870 }2871}287228732874impl<T: Config + Send + Sync> SignedExtension2875 for ChargeTransactionPayment<T>2876where2877 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2878 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2879 T::AccountId: AsRef<[u8]>,2880 T::AccountId: UncheckedFrom<T::Hash>,2881{2882 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2883 type AccountId = T::AccountId;2884 type Call = T::Call;2885 type AdditionalSigned = ();2886 type Pre = (2887 2888 BalanceOf<T>,2889 2890 Self::AccountId,2891 2892 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2893 );2894 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2895 Ok(())2896 }28972898 fn validate(2899 &self,2900 who: &Self::AccountId,2901 call: &Self::Call,2902 info: &DispatchInfoOf<Self::Call>,2903 len: usize,2904 ) -> TransactionValidity {2905 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2906 Ok(ValidTransaction {2907 priority: Self::get_priority(len, info, fee),2908 ..Default::default()2909 })2910 }29112912 fn pre_dispatch(2913 self,2914 who: &Self::AccountId,2915 call: &Self::Call,2916 info: &DispatchInfoOf<Self::Call>,2917 len: usize,2918 ) -> Result<Self::Pre, TransactionValidityError> {2919 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2920 Ok((self.0, who.clone(), imbalance))2921 }29222923 fn post_dispatch(2924 pre: Self::Pre,2925 info: &DispatchInfoOf<Self::Call>,2926 post_info: &PostDispatchInfoOf<Self::Call>,2927 len: usize,2928 _result: &DispatchResult,2929 ) -> Result<(), TransactionValidityError> {2930 let (tip, who, imbalance) = pre;2931 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2932 len as u32,2933 info,2934 post_info,2935 tip,2936 );2937 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2938 Ok(())2939 }2940}29412942