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 codec::{Decode, Encode};17pub use frame_support::{18 construct_runtime, decl_event, decl_module, decl_storage, decl_error,19 dispatch::DispatchResult,20 ensure, fail, parameter_types,21 traits::{22 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23 Randomness, IsSubType, WithdrawReasons,24 },25 weights::{26 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28 WeightToFeePolynomial, DispatchClass,29 },30 StorageValue,31 transactional,32};3334use frame_system::{self as system, ensure_signed, ensure_root};35use sp_runtime::sp_std::prelude::Vec;36use sp_runtime::{37 traits::{38 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,39 },40 transaction_validity::{41 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,42 },43 FixedPointOperand, FixedU128,44};45use sp_runtime::traits::StaticLookup;46use pallet_contracts::chain_extension::UncheckedFrom;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;5657pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;58pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;59pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;60pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6162636465pub type CollectionId = u32;66pub type TokenId = u32;67pub type DecimalPoints = u8;6869#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]70#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]71pub enum CollectionMode {72 Invalid,73 NFT,74 75 Fungible(DecimalPoints),76 ReFungible,77}7879impl Default for CollectionMode {80 fn default() -> Self {81 Self::Invalid82 }83}8485impl Into<u8> for CollectionMode {86 fn into(self) -> u8 {87 match self {88 CollectionMode::Invalid => 0,89 CollectionMode::NFT => 1,90 CollectionMode::Fungible(_) => 2,91 CollectionMode::ReFungible => 3,92 }93 }94}9596#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]97#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]98pub enum AccessMode {99 Normal,100 WhiteList,101}102impl Default for AccessMode {103 fn default() -> Self {104 Self::Normal105 }106}107108#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]109#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]110pub enum SchemaVersion {111 ImageURL,112 Unique,113}114impl Default for SchemaVersion {115 fn default() -> Self {116 Self::ImageURL117 }118}119120#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]121#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]122pub struct Ownership<AccountId> {123 pub owner: AccountId,124 pub fraction: u128,125}126127#[derive(Encode, Decode, Debug, Clone, PartialEq)]128#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]129pub enum SponsorshipState<AccountId> {130 131 Disabled,132 Unconfirmed(AccountId),133 134 Confirmed(AccountId),135}136137impl<AccountId> SponsorshipState<AccountId> {138 fn sponsor(&self) -> Option<&AccountId> {139 match self {140 Self::Confirmed(sponsor) => Some(sponsor),141 _ => None,142 }143 }144145 fn pending_sponsor(&self) -> Option<&AccountId> {146 match self {147 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),148 _ => None,149 }150 }151152 fn confirmed(&self) -> bool {153 matches!(self, Self::Confirmed(_))154 }155}156157impl<T> Default for SponsorshipState<T> {158 fn default() -> Self {159 Self::Disabled160 }161}162163#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]164#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]165pub struct CollectionType<AccountId> {166 pub owner: AccountId,167 pub mode: CollectionMode,168 pub access: AccessMode,169 pub decimal_points: DecimalPoints,170 pub name: Vec<u16>, 171 pub description: Vec<u16>, 172 pub token_prefix: Vec<u8>, 173 pub mint_mode: bool,174 pub offchain_schema: Vec<u8>,175 pub schema_version: SchemaVersion,176 pub sponsorship: SponsorshipState<AccountId>,177 pub limits: CollectionLimits, 178 pub variable_on_chain_schema: Vec<u8>, 179 pub const_on_chain_schema: Vec<u8>, 180}181182#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]183#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]184pub struct NftItemType<AccountId> {185 pub owner: AccountId,186 pub const_data: Vec<u8>,187 pub variable_data: Vec<u8>,188}189190#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]191#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]192pub struct FungibleItemType {193 pub value: u128,194}195196#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]197#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]198pub struct ReFungibleItemType<AccountId> {199 pub owner: Vec<Ownership<AccountId>>,200 pub const_data: Vec<u8>,201 pub variable_data: Vec<u8>,202}203204205206207208209210211212213214215#[derive(Encode, Decode, Debug, Clone, PartialEq)]216#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]217pub struct CollectionLimits {218 pub account_token_ownership_limit: u32,219 pub sponsored_data_size: u32,220 pub token_limit: u32,221222 223 pub sponsor_transfer_timeout: u32,224 pub owner_can_transfer: bool,225 pub owner_can_destroy: bool,226}227228impl Default for CollectionLimits {229 fn default() -> CollectionLimits {230 CollectionLimits { 231 account_token_ownership_limit: 10_000_000, 232 token_limit: u32::max_value(),233 sponsored_data_size: u32::MAX,234 sponsor_transfer_timeout: 14400,235 owner_can_transfer: true,236 owner_can_destroy: true237 }238 }239}240241#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]242#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]243pub struct ChainLimits {244 pub collection_numbers_limit: u32,245 pub account_token_ownership_limit: u32,246 pub collections_admins_limit: u64,247 pub custom_data_limit: u32,248249 250 pub nft_sponsor_transfer_timeout: u32,251 pub fungible_sponsor_transfer_timeout: u32,252 pub refungible_sponsor_transfer_timeout: u32,253254 255 pub offchain_schema_limit: u32,256 pub variable_on_chain_schema_limit: u32,257 pub const_on_chain_schema_limit: u32,258}259260pub trait WeightInfo {261 fn create_collection() -> Weight;262 fn destroy_collection() -> Weight;263 fn add_to_white_list() -> Weight;264 fn remove_from_white_list() -> Weight;265 fn set_public_access_mode() -> Weight;266 fn set_mint_permission() -> Weight;267 fn change_collection_owner() -> Weight;268 fn add_collection_admin() -> Weight;269 fn remove_collection_admin() -> Weight;270 fn set_collection_sponsor() -> Weight;271 fn confirm_sponsorship() -> Weight;272 fn remove_collection_sponsor() -> Weight;273 fn create_item(s: usize) -> Weight;274 fn burn_item() -> Weight;275 fn transfer() -> Weight;276 fn approve() -> Weight;277 fn transfer_from() -> Weight;278 fn set_offchain_schema() -> Weight;279 fn set_const_on_chain_schema() -> Weight;280 fn set_variable_on_chain_schema() -> Weight;281 fn set_variable_meta_data() -> Weight;282 fn enable_contract_sponsoring() -> Weight;283 fn set_schema_version() -> Weight;284 fn set_chain_limits() -> Weight;285 fn set_contract_sponsoring_rate_limit() -> Weight;286 fn toggle_contract_white_list() -> Weight;287 fn add_to_contract_white_list() -> Weight;288 fn remove_from_contract_white_list() -> Weight;289 fn set_collection_limits() -> Weight;290}291292#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]293#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]294pub struct CreateNftData {295 pub const_data: Vec<u8>,296 pub variable_data: Vec<u8>,297}298299#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]300#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]301pub struct CreateFungibleData {302 pub value: u128,303}304305#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]306#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]307pub struct CreateReFungibleData {308 pub const_data: Vec<u8>,309 pub variable_data: Vec<u8>,310 pub pieces: u128,311}312313#[derive(Encode, Decode, Debug, Clone, PartialEq)]314#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]315pub enum CreateItemData {316 NFT(CreateNftData),317 Fungible(CreateFungibleData),318 ReFungible(CreateReFungibleData),319}320321impl CreateItemData {322 pub fn len(&self) -> usize {323 let len = match self {324 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),325 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),326 _ => 0327 };328 329 return len;330 }331}332333impl From<CreateNftData> for CreateItemData {334 fn from(item: CreateNftData) -> Self {335 CreateItemData::NFT(item)336 }337}338339impl From<CreateReFungibleData> for CreateItemData {340 fn from(item: CreateReFungibleData) -> Self {341 CreateItemData::ReFungible(item)342 }343}344345impl From<CreateFungibleData> for CreateItemData {346 fn from(item: CreateFungibleData) -> Self {347 CreateItemData::Fungible(item)348 }349}350351352decl_error! {353 354 pub enum Error for Module<T: Config> {355 356 TotalCollectionsLimitExceeded,357 358 CollectionDecimalPointLimitExceeded, 359 360 CollectionNameLimitExceeded, 361 362 CollectionDescriptionLimitExceeded, 363 364 CollectionTokenPrefixLimitExceeded,365 366 CollectionNotFound,367 368 TokenNotFound,369 370 AdminNotFound,371 372 NumOverflow, 373 374 AlreadyAdmin, 375 376 NoPermission,377 378 ConfirmUnsetSponsorFail,379 380 PublicMintingNotAllowed,381 382 MustBeTokenOwner,383 384 TokenValueTooLow,385 386 NftSizeLimitExceeded,387 388 ApproveNotFound,389 390 TokenValueNotEnough,391 392 ApproveRequired,393 394 AddresNotInWhiteList,395 396 CollectionAdminsLimitExceeded,397 398 AddressOwnershipLimitExceeded,399 400 EmptyArgument,401 402 TokenConstDataLimitExceeded,403 404 TokenVariableDataLimitExceeded,405 406 NotNftDataUsedToMintNftCollectionToken,407 408 NotFungibleDataUsedToMintFungibleCollectionToken,409 410 NotReFungibleDataUsedToMintReFungibleCollectionToken,411 412 UnexpectedCollectionType,413 414 CantStoreMetadataInFungibleTokens,415 416 CollectionTokenLimitExceeded,417 418 AccountTokenLimitExceeded,419 420 CollectionLimitBoundsExceeded,421 422 OwnerPermissionsCantBeReverted,423 424 SchemaDataLimitExceeded,425 426 WrongRefungiblePieces,427 428 BadCreateRefungibleCall,429 }430}431432pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {433 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;434435 436 type WeightInfo: WeightInfo;437438 type Currency: Currency<Self::AccountId>;439 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;440 type TreasuryAccountId: Get<Self::AccountId>;441}442443#[cfg(feature = "runtime-benchmarks")]444mod benchmarking;445446447448449450451452453454455456457458459460461462463464465466467468469470decl_storage! {471 trait Store for Module<T: Config> as Nft {472473 474 475 CreatedCollectionCount: u32;476 477 ChainVersion: u64;478 479 480 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;481 482483 484 pub ChainLimit get(fn chain_limit) config(): ChainLimits;485 486487 488 489 490 DestroyedCollectionCount: u32;491 492 493 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;494 495496 497 498 499 pub Collection get(fn collection) config(): map hasher(blake2_128_concat) CollectionId => CollectionType<T::AccountId>;500 501 502 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;503 504 505 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;506 507508 509 510 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;511512 513 514 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;515516 517 518 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;519 520 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;521 522 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;523 524525 526 527 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;528 529530 531 532 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;533 534 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;535 536 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;537 538 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;539 540541 542 543 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;544 545 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;546 547 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;548 549 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;550 551 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 552 553 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 554 555 }556 add_extra_genesis {557 build(|config: &GenesisConfig<T>| {558 559 for (_num, _c) in &config.collection {560 <Module<T>>::init_collection(_c);561 }562563 for (_num, _c, _i) in &config.nft_item_id {564 <Module<T>>::init_nft_token(*_c, _i);565 }566567 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {568 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);569 }570571 for (_num, _c, _i) in &config.refungible_item_id {572 <Module<T>>::init_refungible_token(*_c, _i);573 }574 })575 }576}577578decl_event!(579 pub enum Event<T>580 where581 AccountId = <T as system::Config>::AccountId,582 {583 584 585 586 587 588 589 590 591 592 Created(CollectionId, u8, AccountId),593594 595 596 597 598 599 600 601 602 603 ItemCreated(CollectionId, TokenId, AccountId),604605 606 607 608 609 610 611 612 ItemDestroyed(CollectionId, TokenId),613614 615 616 617 618 619 620 621 622 623 624 625 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),626 }627);628629decl_module! {630 pub struct Module<T: Config> for enum Call 631 where 632 origin: T::Origin633 {634 fn deposit_event() = default;635 type Error = Error<T>;636637 fn on_initialize(now: T::BlockNumber) -> Weight {638 0639 }640641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 #[weight = <T as Config>::WeightInfo::create_collection()]658 #[transactional]659 pub fn create_collection(origin,660 collection_name: Vec<u16>,661 collection_description: Vec<u16>,662 token_prefix: Vec<u8>,663 mode: CollectionMode) -> DispatchResult {664665 666 let who = ensure_signed(origin)?;667668 669 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();670 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(671 &T::TreasuryAccountId::get(),672 T::CollectionCreationPrice::get(),673 ));674 <T as Config>::Currency::settle(675 &who,676 imbalance,677 WithdrawReasons::TRANSFER,678 ExistenceRequirement::KeepAlive,679 ).map_err(|_| Error::<T>::NoPermission)?;680681 let decimal_points = match mode {682 CollectionMode::Fungible(points) => points,683 _ => 0684 };685686 let chain_limit = ChainLimit::get();687688 let created_count = CreatedCollectionCount::get();689 let destroyed_count = DestroyedCollectionCount::get();690691 692 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);693694 695 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);696 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);697 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);698 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);699700 701 let next_id = created_count702 .checked_add(1)703 .ok_or(Error::<T>::NumOverflow)?;704705 CreatedCollectionCount::put(next_id);706707 let limits = CollectionLimits {708 sponsored_data_size: chain_limit.custom_data_limit,709 ..Default::default()710 };711712 713 let new_collection = CollectionType {714 owner: who.clone(),715 name: collection_name,716 mode: mode.clone(),717 mint_mode: false,718 access: AccessMode::Normal,719 description: collection_description,720 decimal_points: decimal_points,721 token_prefix: token_prefix,722 offchain_schema: Vec::new(),723 schema_version: SchemaVersion::ImageURL,724 sponsorship: SponsorshipState::Disabled,725 variable_on_chain_schema: Vec::new(),726 const_on_chain_schema: Vec::new(),727 limits,728 };729730 731 <Collection<T>>::insert(next_id, new_collection);732733 734 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));735736 Ok(())737 }738739 740 741 742 743 744 745 746 747 748 #[weight = <T as Config>::WeightInfo::destroy_collection()]749 #[transactional]750 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {751752 let sender = ensure_signed(origin)?;753 Self::check_owner_permissions(collection_id, sender)?;754755 let target_collection = <Collection<T>>::get(collection_id);756 if !target_collection.limits.owner_can_destroy {757 fail!(Error::<T>::NoPermission);758 }759760 <AddressTokens<T>>::remove_prefix(collection_id);761 <Allowances<T>>::remove_prefix(collection_id);762 <Balance<T>>::remove_prefix(collection_id);763 <ItemListIndex>::remove(collection_id);764 <AdminList<T>>::remove(collection_id);765 <Collection<T>>::remove(collection_id);766 <WhiteList<T>>::remove_prefix(collection_id);767768 <NftItemList<T>>::remove_prefix(collection_id);769 <FungibleItemList<T>>::remove_prefix(collection_id);770 <ReFungibleItemList<T>>::remove_prefix(collection_id);771772 <NftTransferBasket<T>>::remove_prefix(collection_id);773 <FungibleTransferBasket<T>>::remove_prefix(collection_id);774 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);775776 DestroyedCollectionCount::put(DestroyedCollectionCount::get()777 .checked_add(1)778 .ok_or(Error::<T>::NumOverflow)?);779780 Ok(())781 }782783 784 785 786 787 788 789 790 791 792 793 794 795 #[weight = <T as Config>::WeightInfo::add_to_white_list()]796 #[transactional]797 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{798799 let sender = ensure_signed(origin)?;800 Self::check_owner_or_admin_permissions(collection_id, sender)?;801802 <WhiteList<T>>::insert(collection_id, address, true);803 804 Ok(())805 }806807 808 809 810 811 812 813 814 815 816 817 818 819 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]820 #[transactional]821 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{822823 let sender = ensure_signed(origin)?;824 Self::check_owner_or_admin_permissions(collection_id, sender)?;825826 <WhiteList<T>>::remove(collection_id, address);827828 Ok(())829 }830831 832 833 834 835 836 837 838 839 840 841 842 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]843 #[transactional]844 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult845 {846 let sender = ensure_signed(origin)?;847848 Self::check_owner_permissions(collection_id, sender)?;849 let mut target_collection = <Collection<T>>::get(collection_id);850 target_collection.access = mode;851 <Collection<T>>::insert(collection_id, target_collection);852853 Ok(())854 }855856 857 858 859 860 861 862 863 864 865 866 867 868 869 #[weight = <T as Config>::WeightInfo::set_mint_permission()]870 #[transactional]871 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult872 {873 let sender = ensure_signed(origin)?;874875 Self::check_owner_permissions(collection_id, sender)?;876 let mut target_collection = <Collection<T>>::get(collection_id);877 target_collection.mint_mode = mint_permission;878 <Collection<T>>::insert(collection_id, target_collection);879880 Ok(())881 }882883 884 885 886 887 888 889 890 891 892 893 894 #[weight = <T as Config>::WeightInfo::change_collection_owner()]895 #[transactional]896 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {897898 let sender = ensure_signed(origin)?;899 Self::check_owner_permissions(collection_id, sender)?;900 let mut target_collection = <Collection<T>>::get(collection_id);901 target_collection.owner = new_owner;902 <Collection<T>>::insert(collection_id, target_collection);903904 Ok(())905 }906907 908 909 910 911 912 913 914 915 916 917 918 919 920 #[weight = <T as Config>::WeightInfo::add_collection_admin()]921 #[transactional]922 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {923924 let sender = ensure_signed(origin)?;925 Self::check_owner_or_admin_permissions(collection_id, sender)?;926 let mut admin_arr: Vec<T::AccountId> = Vec::new();927928 if <AdminList<T>>::contains_key(collection_id)929 {930 admin_arr = <AdminList<T>>::get(collection_id);931 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);932 }933934 935 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);936937 admin_arr.push(new_admin_id);938 <AdminList<T>>::insert(collection_id, admin_arr);939940 Ok(())941 }942943 944 945 946 947 948 949 950 951 952 953 954 955 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]956 #[transactional]957 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {958959 let sender = ensure_signed(origin)?;960 Self::check_owner_or_admin_permissions(collection_id, sender)?;961 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);962963 let mut admin_arr = <AdminList<T>>::get(collection_id);964 admin_arr.retain(|i| *i != account_id);965 <AdminList<T>>::insert(collection_id, admin_arr);966967 Ok(())968 }969970 971 972 973 974 975 976 977 978 979 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]980 #[transactional]981 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {982983 let sender = ensure_signed(origin)?;984 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);985986 let mut target_collection = <Collection<T>>::get(collection_id);987 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);988989 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);990 <Collection<T>>::insert(collection_id, target_collection);991992 Ok(())993 }994995 996 997 998 999 1000 1001 1002 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1003 #[transactional]1004 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10051006 let sender = ensure_signed(origin)?;1007 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10081009 let mut target_collection = <Collection<T>>::get(collection_id);1010 ensure!(1011 target_collection.sponsorship.pending_sponsor() == Some(&sender),1012 Error::<T>::ConfirmUnsetSponsorFail1013 );10141015 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1016 <Collection<T>>::insert(collection_id, target_collection);10171018 Ok(())1019 }10201021 1022 1023 1024 1025 1026 1027 1028 1029 1030 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1031 #[transactional]1032 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10331034 let sender = ensure_signed(origin)?;1035 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10361037 let mut target_collection = <Collection<T>>::get(collection_id);1038 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10391040 target_collection.sponsorship = SponsorshipState::Disabled;1041 <Collection<T>>::insert(collection_id, target_collection);10421043 Ok(())1044 }10451046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 10691070 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1071 #[transactional]1072 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10731074 let sender = ensure_signed(origin)?;10751076 Self::collection_exists(collection_id)?;10771078 let target_collection = <Collection<T>>::get(collection_id);10791080 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1081 Self::validate_create_item_args(&target_collection, &data)?;1082 Self::create_item_no_validation(collection_id, owner, data)?;10831084 Ok(())1085 }10861087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1106 .map(|data| { data.len() })1107 .sum())]1108 #[transactional]1109 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11101111 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1112 let sender = ensure_signed(origin)?;11131114 Self::collection_exists(collection_id)?;1115 let target_collection = <Collection<T>>::get(collection_id);11161117 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11181119 for data in &items_data {1120 Self::validate_create_item_args(&target_collection, data)?;1121 }1122 for data in &items_data {1123 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1124 }11251126 Ok(())1127 }11281129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 #[weight = <T as Config>::WeightInfo::burn_item()]1143 #[transactional]1144 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11451146 let sender = ensure_signed(origin)?;1147 Self::collection_exists(collection_id)?;11481149 1150 let target_collection = <Collection<T>>::get(collection_id);1151 ensure!(1152 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1153 (1154 target_collection.limits.owner_can_transfer &&1155 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1156 ),1157 Error::<T>::NoPermission1158 );11591160 if target_collection.access == AccessMode::WhiteList {1161 Self::check_white_list(collection_id, &sender)?;1162 }11631164 match target_collection.mode1165 {1166 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1167 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1168 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1169 _ => ()1170 };11711172 1173 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11741175 Ok(())1176 }11771178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 #[weight = <T as Config>::WeightInfo::transfer()]1202 #[transactional]1203 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1204 let sender = ensure_signed(origin)?;1205 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1206 }12071208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 #[weight = <T as Config>::WeightInfo::approve()]1224 #[transactional]1225 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12261227 let sender = ensure_signed(origin)?;12281229 Self::collection_exists(collection_id)?;1230 Self::token_exists(collection_id, item_id, &sender)?;12311232 1233 let target_collection = <Collection<T>>::get(collection_id);1234 let allowance_limit = if target_collection.limits.owner_can_transfer &&1235 Self::is_owner_or_admin_permissions(1236 collection_id,1237 sender.clone(),1238 ) {1239 None1240 } else if let Some(amount) = Self::owned_amount(1241 sender.clone(),1242 collection_id,1243 item_id,1244 ) {1245 Some(amount)1246 } else {1247 fail!(Error::<T>::NoPermission);1248 };12491250 if target_collection.access == AccessMode::WhiteList {1251 Self::check_white_list(collection_id, &sender)?;1252 Self::check_white_list(collection_id, &spender)?;1253 }12541255 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1256 let mut allowance: u128 = amount;1257 if allowance_exists {1258 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1259 }1260 if let Some(limit) = allowance_limit {1261 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1262 }1263 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12641265 Ok(())1266 }1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 #[weight = <T as Config>::WeightInfo::transfer_from()]1288 #[transactional]1289 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12901291 let sender = ensure_signed(origin)?;1292 let mut appoved_transfer = false;12931294 1295 let mut approval: u128 = 0;1296 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1297 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1298 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1299 appoved_transfer = true;1300 }13011302 let target_collection = <Collection<T>>::get(collection_id);13031304 1305 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;13061307 1308 ensure!(1309 appoved_transfer || 1310 (1311 target_collection.limits.owner_can_transfer &&1312 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1313 ),1314 Error::<T>::NoPermission1315 );13161317 if target_collection.access == AccessMode::WhiteList {1318 Self::check_white_list(collection_id, &sender)?;1319 Self::check_white_list(collection_id, &recipient)?;1320 }13211322 1323 if approval.saturating_sub(value) > 0 {1324 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1325 }1326 else {1327 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1328 }13291330 match target_collection.mode1331 {1332 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1333 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1334 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1335 _ => ()1336 };13371338 Ok(())1339 }13401341 1342 13431344 1345 1346 1347 13481349 13501351 13521353 1354 13551356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1369 #[transactional]1370 pub fn set_variable_meta_data (1371 origin,1372 collection_id: CollectionId,1373 item_id: TokenId,1374 data: Vec<u8>1375 ) -> DispatchResult {1376 let sender = ensure_signed(origin)?;1377 1378 Self::collection_exists(collection_id)?;1379 Self::token_exists(collection_id, item_id, &sender)?;13801381 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13821383 1384 let target_collection = <Collection<T>>::get(collection_id);1385 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1386 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1387 Error::<T>::NoPermission);13881389 match target_collection.mode1390 {1391 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1392 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1393 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1394 _ => fail!(Error::<T>::UnexpectedCollectionType)1395 };13961397 Ok(())1398 }1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 #[weight = <T as Config>::WeightInfo::set_schema_version()]1415 #[transactional]1416 pub fn set_schema_version(1417 origin,1418 collection_id: CollectionId,1419 version: SchemaVersion1420 ) -> DispatchResult {1421 let sender = ensure_signed(origin)?;1422 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1423 let mut target_collection = <Collection<T>>::get(collection_id);1424 target_collection.schema_version = version;1425 <Collection<T>>::insert(collection_id, target_collection);14261427 Ok(())1428 }14291430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1443 #[transactional]1444 pub fn set_offchain_schema(1445 origin,1446 collection_id: CollectionId,1447 schema: Vec<u8>1448 ) -> DispatchResult {1449 let sender = ensure_signed(origin)?;1450 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14511452 1453 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14541455 let mut target_collection = <Collection<T>>::get(collection_id);1456 target_collection.offchain_schema = schema;1457 <Collection<T>>::insert(collection_id, target_collection);14581459 Ok(())1460 }14611462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1475 #[transactional]1476 pub fn set_const_on_chain_schema (1477 origin,1478 collection_id: CollectionId,1479 schema: Vec<u8>1480 ) -> DispatchResult {1481 let sender = ensure_signed(origin)?;1482 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14831484 1485 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14861487 let mut target_collection = <Collection<T>>::get(collection_id);1488 target_collection.const_on_chain_schema = schema;1489 <Collection<T>>::insert(collection_id, target_collection);14901491 Ok(())1492 }14931494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1507 #[transactional]1508 pub fn set_variable_on_chain_schema (1509 origin,1510 collection_id: CollectionId,1511 schema: Vec<u8>1512 ) -> DispatchResult {1513 let sender = ensure_signed(origin)?;1514 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;15151516 1517 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15181519 let mut target_collection = <Collection<T>>::get(collection_id);1520 target_collection.variable_on_chain_schema = schema;1521 <Collection<T>>::insert(collection_id, target_collection);15221523 Ok(())1524 }15251526 1527 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1528 #[transactional]1529 pub fn set_chain_limits(1530 origin,1531 limits: ChainLimits1532 ) -> DispatchResult {15331534 #[cfg(not(feature = "runtime-benchmarks"))]1535 ensure_root(origin)?;15361537 <ChainLimit>::put(limits);1538 Ok(())1539 }15401541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1553 #[transactional]1554 pub fn enable_contract_sponsoring(1555 origin,1556 contract_address: T::AccountId,1557 enable: bool1558 ) -> DispatchResult {15591560 let sender = ensure_signed(origin)?;15611562 #[cfg(feature = "runtime-benchmarks")]1563 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15641565 Self::ensure_contract_owned(sender, &contract_address)?;15661567 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1568 Ok(())1569 }15701571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1589 #[transactional]1590 pub fn set_contract_sponsoring_rate_limit(1591 origin,1592 contract_address: T::AccountId,1593 rate_limit: T::BlockNumber1594 ) -> DispatchResult {1595 let sender = ensure_signed(origin)?;15961597 #[cfg(feature = "runtime-benchmarks")]1598 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15991600 Self::ensure_contract_owned(sender, &contract_address)?;1601 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1602 Ok(())1603 }16041605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1617 #[transactional]1618 pub fn toggle_contract_white_list(1619 origin,1620 contract_address: T::AccountId,1621 enable: bool1622 ) -> DispatchResult {1623 let sender = ensure_signed(origin)?;16241625 #[cfg(feature = "runtime-benchmarks")]1626 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16271628 Self::ensure_contract_owned(sender, &contract_address)?;1629 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1630 Ok(())1631 }1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1645 #[transactional]1646 pub fn add_to_contract_white_list(1647 origin,1648 contract_address: T::AccountId,1649 account_address: T::AccountId1650 ) -> DispatchResult {1651 let sender = ensure_signed(origin)?;16521653 #[cfg(feature = "runtime-benchmarks")]1654 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1655 1656 Self::ensure_contract_owned(sender, &contract_address)?; 1657 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1658 Ok(())1659 }16601661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1673 #[transactional]1674 pub fn remove_from_contract_white_list(1675 origin,1676 contract_address: T::AccountId,1677 account_address: T::AccountId1678 ) -> DispatchResult {1679 let sender = ensure_signed(origin)?;16801681 #[cfg(feature = "runtime-benchmarks")]1682 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16831684 Self::ensure_contract_owned(sender, &contract_address)?;1685 <ContractWhiteList<T>>::remove(contract_address, account_address);1686 Ok(())1687 }16881689 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1690 #[transactional]1691 pub fn set_collection_limits(1692 origin,1693 collection_id: u32,1694 new_limits: CollectionLimits,1695 ) -> DispatchResult {1696 let sender = ensure_signed(origin)?;1697 Self::check_owner_permissions(collection_id, sender.clone())?;1698 let mut target_collection = <Collection<T>>::get(collection_id);1699 let old_limits = target_collection.limits;1700 let chain_limits = ChainLimit::get();17011702 1703 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1704 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1705 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1706 Error::<T>::CollectionLimitBoundsExceeded);17071708 1709 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1710 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17111712 ensure!(1713 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1714 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1715 Error::<T>::OwnerPermissionsCantBeReverted,1716 );17171718 target_collection.limits = new_limits;1719 <Collection<T>>::insert(collection_id, target_collection);17201721 Ok(())1722 } 1723 }1724}17251726impl<T: Config> Module<T> {17271728 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17291730 let target_collection = <Collection<T>>::get(collection_id);17311732 1733 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17341735 1736 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1737 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1738 Error::<T>::NoPermission);17391740 if target_collection.access == AccessMode::WhiteList {1741 Self::check_white_list(collection_id, &sender)?;1742 Self::check_white_list(collection_id, &recipient)?;1743 }17441745 match target_collection.mode1746 {1747 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1748 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1749 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1750 _ => ()1751 };17521753 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17541755 Ok(())1756 }175717581759 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17601761 1762 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1763 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1764 1765 Ok(())1766 }17671768 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17691770 1771 let total_items: u32 = ItemListIndex::get(collection_id);1772 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1773 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1774 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17751776 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1777 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1778 Self::check_white_list(collection_id, owner)?;1779 Self::check_white_list(collection_id, sender)?;1780 }17811782 Ok(())1783 }17841785 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1786 match target_collection.mode1787 {1788 CollectionMode::NFT => {1789 if let CreateItemData::NFT(data) = data {1790 1791 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1792 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1793 } else {1794 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1795 }1796 },1797 CollectionMode::Fungible(_) => {1798 if let CreateItemData::Fungible(_) = data {1799 } else {1800 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1801 }1802 },1803 CollectionMode::ReFungible => {1804 if let CreateItemData::ReFungible(data) = data {18051806 1807 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1808 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18091810 1811 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1812 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1813 } else {1814 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1815 }1816 },1817 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1818 };18191820 Ok(())1821 }18221823 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1824 match data1825 {1826 CreateItemData::NFT(data) => {1827 let item = NftItemType {1828 owner: owner.clone(),1829 const_data: data.const_data,1830 variable_data: data.variable_data1831 };18321833 Self::add_nft_item(collection_id, item)?;1834 },1835 CreateItemData::Fungible(data) => {1836 Self::add_fungible_item(collection_id, &owner, data.value)?;1837 },1838 CreateItemData::ReFungible(data) => {1839 let mut owner_list = Vec::new();1840 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18411842 let item = ReFungibleItemType {1843 owner: owner_list,1844 const_data: data.const_data,1845 variable_data: data.variable_data1846 };18471848 Self::add_refungible_item(collection_id, item)?;1849 }1850 };18511852 Ok(())1853 }18541855 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18561857 1858 let mut balance: u128 = 0;1859 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1860 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1861 } 18621863 1864 let item = FungibleItemType {1865 value: balance + value1866 };1867 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18681869 1870 let new_balance = <Balance<T>>::get(collection_id, owner)1871 .checked_add(value)1872 .ok_or(Error::<T>::NumOverflow)?;1873 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18741875 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1876 Ok(())1877 }18781879 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1880 let current_index = <ItemListIndex>::get(collection_id)1881 .checked_add(1)1882 .ok_or(Error::<T>::NumOverflow)?;1883 let itemcopy = item.clone();18841885 ensure!(1886 item.owner.len() == 1,1887 Error::<T>::BadCreateRefungibleCall,1888 );1889 let item_owner = item.owner.first().expect("only one owner is defined");18901891 let value = item_owner.fraction;1892 let owner = item_owner.owner.clone();18931894 Self::add_token_index(collection_id, current_index, &owner)?;18951896 <ItemListIndex>::insert(collection_id, current_index);1897 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18981899 1900 let new_balance = <Balance<T>>::get(collection_id, &owner)1901 .checked_add(value)1902 .ok_or(Error::<T>::NumOverflow)?;1903 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19041905 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1906 Ok(())1907 }19081909 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1910 let current_index = <ItemListIndex>::get(collection_id)1911 .checked_add(1)1912 .ok_or(Error::<T>::NumOverflow)?;19131914 let item_owner = item.owner.clone();1915 Self::add_token_index(collection_id, current_index, &item.owner)?;19161917 <ItemListIndex>::insert(collection_id, current_index);1918 <NftItemList<T>>::insert(collection_id, current_index, item);19191920 1921 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1922 .checked_add(1)1923 .ok_or(Error::<T>::NumOverflow)?;1924 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19251926 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1927 Ok(())1928 }19291930 fn burn_refungible_item(1931 collection_id: CollectionId,1932 item_id: TokenId,1933 owner: &T::AccountId,1934 ) -> DispatchResult {1935 ensure!(1936 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1937 Error::<T>::TokenNotFound1938 );1939 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1940 let rft_balance = token1941 .owner1942 .iter()1943 .find(|&i| i.owner == *owner)1944 .ok_or(Error::<T>::TokenNotFound)?;1945 Self::remove_token_index(collection_id, item_id, owner)?;19461947 1948 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1949 .checked_sub(rft_balance.fraction)1950 .ok_or(Error::<T>::NumOverflow)?;1951 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19521953 1954 let index = token1955 .owner1956 .iter()1957 .position(|i| i.owner == *owner)1958 .expect("owned item is exists");1959 token.owner.remove(index);1960 let owner_count = token.owner.len();19611962 1963 if owner_count == 0 {1964 <ReFungibleItemList<T>>::remove(collection_id, item_id);1965 }1966 else {1967 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1968 }19691970 Ok(())1971 }19721973 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1974 ensure!(1975 <NftItemList<T>>::contains_key(collection_id, item_id),1976 Error::<T>::TokenNotFound1977 );1978 let item = <NftItemList<T>>::get(collection_id, item_id);1979 Self::remove_token_index(collection_id, item_id, &item.owner)?;19801981 1982 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1983 .checked_sub(1)1984 .ok_or(Error::<T>::NumOverflow)?;1985 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1986 <NftItemList<T>>::remove(collection_id, item_id);19871988 Ok(())1989 }19901991 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1992 ensure!(1993 <FungibleItemList<T>>::contains_key(collection_id, owner),1994 Error::<T>::TokenNotFound1995 );1996 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1997 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19981999 2000 let new_balance = <Balance<T>>::get(collection_id, owner)2001 .checked_sub(value)2002 .ok_or(Error::<T>::NumOverflow)?;2003 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20042005 if balance.value - value > 0 {2006 balance.value -= value;2007 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2008 }2009 else {2010 <FungibleItemList<T>>::remove(collection_id, owner);2011 }20122013 Ok(())2014 }20152016 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2017 ensure!(2018 <Collection<T>>::contains_key(collection_id),2019 Error::<T>::CollectionNotFound2020 );2021 Ok(())2022 }20232024 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2025 Self::collection_exists(collection_id)?;20262027 let target_collection = <Collection<T>>::get(collection_id);2028 ensure!(2029 subject == target_collection.owner,2030 Error::<T>::NoPermission2031 );20322033 Ok(())2034 }20352036 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2037 let target_collection = <Collection<T>>::get(collection_id);2038 let mut result: bool = subject == target_collection.owner;2039 let exists = <AdminList<T>>::contains_key(collection_id);20402041 if !result & exists {2042 if <AdminList<T>>::get(collection_id).contains(&subject) {2043 result = true2044 }2045 }20462047 result2048 }20492050 fn check_owner_or_admin_permissions(2051 collection_id: CollectionId,2052 subject: T::AccountId,2053 ) -> DispatchResult {2054 Self::collection_exists(collection_id)?;2055 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20562057 ensure!(2058 result,2059 Error::<T>::NoPermission2060 );2061 Ok(())2062 }20632064 fn owned_amount(2065 subject: T::AccountId,2066 collection_id: CollectionId,2067 item_id: TokenId,2068 ) -> Option<u128> {2069 let target_collection = <Collection<T>>::get(collection_id);20702071 match target_collection.mode {2072 CollectionMode::NFT => {2073 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2074 return Some(1)2075 }2076 None2077 },2078 CollectionMode::Fungible(_) => {2079 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2080 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2081 .value);2082 }2083 None2084 },2085 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2086 .owner2087 .iter()2088 .find(|i| i.owner == subject)2089 .map(|i| i.fraction),2090 CollectionMode::Invalid => None,2091 }2092 }20932094 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2095 let target_collection = <Collection<T>>::get(collection_id);20962097 match target_collection.mode {2098 CollectionMode::NFT => {2099 <NftItemList<T>>::get(collection_id, item_id).owner == subject2100 }2101 CollectionMode::Fungible(_) => {2102 <FungibleItemList<T>>::contains_key(collection_id, &subject)2103 }2104 CollectionMode::ReFungible => {2105 <ReFungibleItemList<T>>::get(collection_id, item_id)2106 .owner2107 .iter()2108 .any(|i| i.owner == subject)2109 }2110 CollectionMode::Invalid => false,2111 }2112 }21132114 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2115 let mes = Error::<T>::AddresNotInWhiteList;2116 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21172118 Ok(())2119 }21202121 2122 2123 fn token_exists(2124 collection_id: CollectionId,2125 item_id: TokenId,2126 owner: &T::AccountId2127 ) -> DispatchResult {2128 let target_collection = <Collection<T>>::get(collection_id);2129 let exists = match target_collection.mode2130 {2131 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2132 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2133 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2134 _ => false2135 };21362137 ensure!(exists == true, Error::<T>::TokenNotFound);2138 Ok(())2139 }21402141 fn transfer_fungible(2142 collection_id: CollectionId,2143 value: u128,2144 owner: &T::AccountId,2145 recipient: &T::AccountId,2146 ) -> DispatchResult {2147 Self::token_exists(collection_id, 0, owner)?;21482149 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2150 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21512152 2153 Self::add_fungible_item(collection_id, recipient, value)?;21542155 2156 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21572158 2159 if balance.value == value {2160 <FungibleItemList<T>>::remove(collection_id, owner);2161 }2162 else {2163 balance.value -= value;2164 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2165 }21662167 Ok(())2168 }21692170 fn transfer_refungible(2171 collection_id: CollectionId,2172 item_id: TokenId,2173 value: u128,2174 owner: T::AccountId,2175 new_owner: T::AccountId,2176 ) -> DispatchResult {2177 Self::token_exists(collection_id, item_id, &owner)?;21782179 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2180 let item = full_item2181 .owner2182 .iter()2183 .filter(|i| i.owner == owner)2184 .next()2185 .ok_or(Error::<T>::TokenNotFound)?;2186 let amount = item.fraction;21872188 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21892190 2191 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2192 .checked_sub(value)2193 .ok_or(Error::<T>::NumOverflow)?;2194 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21952196 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2197 .checked_add(value)2198 .ok_or(Error::<T>::NumOverflow)?;2199 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22002201 let old_owner = item.owner.clone();2202 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22032204 2205 if amount == value && !new_owner_has_account {2206 2207 2208 let mut new_full_item = full_item.clone();2209 new_full_item2210 .owner2211 .iter_mut()2212 .find(|i| i.owner == owner)2213 .expect("old owner does present in refungible")2214 .owner = new_owner.clone();2215 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22162217 2218 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2219 } else {2220 let mut new_full_item = full_item.clone();2221 new_full_item2222 .owner2223 .iter_mut()2224 .find(|i| i.owner == owner)2225 .expect("old owner does present in refungible")2226 .fraction -= value;22272228 2229 if new_owner_has_account {2230 2231 new_full_item2232 .owner2233 .iter_mut()2234 .find(|i| i.owner == new_owner)2235 .expect("new owner has account")2236 .fraction += value;2237 } else {2238 2239 new_full_item.owner.push(Ownership {2240 owner: new_owner.clone(),2241 fraction: value,2242 });2243 Self::add_token_index(collection_id, item_id, &new_owner)?;2244 }22452246 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2247 }22482249 Ok(())2250 }22512252 fn transfer_nft(2253 collection_id: CollectionId,2254 item_id: TokenId,2255 sender: T::AccountId,2256 new_owner: T::AccountId,2257 ) -> DispatchResult {2258 Self::token_exists(collection_id, item_id, &sender)?;22592260 let mut item = <NftItemList<T>>::get(collection_id, item_id);22612262 ensure!(2263 sender == item.owner,2264 Error::<T>::MustBeTokenOwner2265 );22662267 2268 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2269 .checked_sub(1)2270 .ok_or(Error::<T>::NumOverflow)?;2271 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22722273 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2274 .checked_add(1)2275 .ok_or(Error::<T>::NumOverflow)?;2276 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22772278 2279 let old_owner = item.owner.clone();2280 item.owner = new_owner.clone();2281 <NftItemList<T>>::insert(collection_id, item_id, item);22822283 2284 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22852286 Ok(())2287 }2288 2289 fn set_re_fungible_variable_data(2290 collection_id: CollectionId,2291 item_id: TokenId,2292 data: Vec<u8>2293 ) -> DispatchResult {2294 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22952296 item.variable_data = data;22972298 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22992300 Ok(())2301 }23022303 fn set_nft_variable_data(2304 collection_id: CollectionId,2305 item_id: TokenId,2306 data: Vec<u8>2307 ) -> DispatchResult {2308 let mut item = <NftItemList<T>>::get(collection_id, item_id);2309 2310 item.variable_data = data;23112312 <NftItemList<T>>::insert(collection_id, item_id, item);2313 2314 Ok(())2315 }23162317 fn init_collection(item: &CollectionType<T::AccountId>) {2318 2319 assert!(2320 item.decimal_points <= MAX_DECIMAL_POINTS,2321 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2322 );2323 assert!(2324 item.name.len() <= 64,2325 "Collection name can not be longer than 63 char"2326 );2327 assert!(2328 item.name.len() <= 256,2329 "Collection description can not be longer than 255 char"2330 );2331 assert!(2332 item.token_prefix.len() <= 16,2333 "Token prefix can not be longer than 15 char"2334 );23352336 2337 let next_id = CreatedCollectionCount::get()2338 .checked_add(1)2339 .unwrap();23402341 CreatedCollectionCount::put(next_id);2342 }23432344 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2345 let current_index = <ItemListIndex>::get(collection_id)2346 .checked_add(1)2347 .unwrap();23482349 let item_owner = item.owner.clone();2350 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23512352 <ItemListIndex>::insert(collection_id, current_index);23532354 2355 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2356 .checked_add(1)2357 .unwrap();2358 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2359 }23602361 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2362 let current_index = <ItemListIndex>::get(collection_id)2363 .checked_add(1)2364 .unwrap();23652366 Self::add_token_index(collection_id, current_index, owner).unwrap();23672368 <ItemListIndex>::insert(collection_id, current_index);23692370 2371 let new_balance = <Balance<T>>::get(collection_id, owner)2372 .checked_add(item.value)2373 .unwrap();2374 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2375 }23762377 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2378 let current_index = <ItemListIndex>::get(collection_id)2379 .checked_add(1)2380 .unwrap();23812382 let value = item.owner.first().unwrap().fraction;2383 let owner = item.owner.first().unwrap().owner.clone();23842385 Self::add_token_index(collection_id, current_index, &owner).unwrap();23862387 <ItemListIndex>::insert(collection_id, current_index);23882389 2390 let new_balance = <Balance<T>>::get(collection_id, &owner)2391 .checked_add(value)2392 .unwrap();2393 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2394 }23952396 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23972398 2399 if <AccountItemCount<T>>::contains_key(owner) {24002401 2402 let count = <AccountItemCount<T>>::get(owner);2403 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24042405 <AccountItemCount<T>>::insert(owner.clone(), count2406 .checked_add(1)2407 .ok_or(Error::<T>::NumOverflow)?);2408 }2409 else {2410 <AccountItemCount<T>>::insert(owner.clone(), 1);2411 }24122413 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2414 if list_exists {2415 let mut list = <AddressTokens<T>>::get(collection_id, owner);2416 let item_contains = list.contains(&item_index.clone());24172418 if !item_contains {2419 list.push(item_index.clone());2420 }24212422 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2423 } else {2424 let mut itm = Vec::new();2425 itm.push(item_index.clone());2426 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2427 }24282429 Ok(())2430 }24312432 fn remove_token_index(2433 collection_id: CollectionId,2434 item_index: TokenId,2435 owner: &T::AccountId,2436 ) -> DispatchResult {24372438 2439 <AccountItemCount<T>>::insert(owner.clone(), 2440 <AccountItemCount<T>>::get(owner)2441 .checked_sub(1)2442 .ok_or(Error::<T>::NumOverflow)?);244324442445 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2446 if list_exists {2447 let mut list = <AddressTokens<T>>::get(collection_id, owner);2448 let item_contains = list.contains(&item_index.clone());24492450 if item_contains {2451 list.retain(|&item| item != item_index);2452 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2453 }2454 }24552456 Ok(())2457 }24582459 fn move_token_index(2460 collection_id: CollectionId,2461 item_index: TokenId,2462 old_owner: &T::AccountId,2463 new_owner: &T::AccountId,2464 ) -> DispatchResult {2465 Self::remove_token_index(collection_id, item_index, old_owner)?;2466 Self::add_token_index(collection_id, item_index, new_owner)?;24672468 Ok(())2469 }2470 2471 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2472 if <ContractOwner<T>>::contains_key(contract.clone()) {2473 let owner = <ContractOwner<T>>::get(contract);2474 ensure!(account == owner, Error::<T>::NoPermission);2475 } else {2476 fail!(Error::<T>::NoPermission);2477 }24782479 Ok(())2480 }2481}2482248324842485248624872488pub type Multiplier = FixedU128;24892490type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2491249224932494#[derive(Encode, Decode, Clone, Eq, PartialEq)]2495pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24962497impl<T: Config + Send + Sync> sp_std::fmt::Debug 2498 for ChargeTransactionPayment<T>2499{2500 #[cfg(feature = "std")]2501 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2502 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2503 }2504 #[cfg(not(feature = "std"))]2505 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2506 Ok(())2507 }2508}25092510impl<T: Config> ChargeTransactionPayment<T>2511where2512 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2513 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2514 T::AccountId: AsRef<[u8]>,2515 T::AccountId: UncheckedFrom<T::Hash>,2516{2517 fn traditional_fee(2518 len: usize,2519 info: &DispatchInfoOf<T::Call>,2520 tip: BalanceOf<T>,2521 ) -> BalanceOf<T>2522 where2523 T::Call: Dispatchable<Info = DispatchInfo>,2524 {2525 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2526 }25272528 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2529 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2530 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2531 let len_saturation = max_block_length as u64 / (len as u64).max(1);2532 let coefficient: BalanceOf<T> = weight_saturation2533 .min(len_saturation)2534 .saturated_into::<BalanceOf<T>>();2535 final_fee2536 .saturating_mul(coefficient)2537 .saturated_into::<TransactionPriority>()2538 }25392540 fn withdraw_fee(2541 &self,2542 who: &T::AccountId,2543 call: &T::Call,2544 info: &DispatchInfoOf<T::Call>,2545 len: usize,2546 ) -> Result<2547 (2548 BalanceOf<T>,2549 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2550 ),2551 TransactionValidityError,2552 > {2553 let tip = self.0;25542555 let fee = Self::traditional_fee(len, info, tip);25562557 2558 if fee.is_zero() {2559 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2560 .map(|i| (fee, i));2561 }25622563 2564 2565 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2566 Some(Call::create_item(collection_id, _owner, _properties)) => {25672568 2569 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25702571 let collection = <Collection<T>>::get(collection_id);25722573 let limit = collection.limits.sponsor_transfer_timeout;2574 let mut sponsored = true;2575 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2576 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2577 let limit_time = last_tx_block + limit.into();2578 if block_number <= limit_time {2579 sponsored = false;2580 }2581 }2582 if sponsored {2583 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2584 }25852586 2587 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2588 (sponsored)2589 {2590 collection.sponsorship.sponsor()2591 .cloned()2592 .unwrap_or_default()2593 } else {2594 T::AccountId::default()2595 }2596 }2597 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2598 2599 let mut sponsor_transfer = false;2600 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {26012602 let collection_limits = <Collection<T>>::get(collection_id).limits;2603 let collection_mode = <Collection<T>>::get(collection_id).mode;2604 2605 2606 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2607 sponsor_transfer = match collection_mode {2608 CollectionMode::NFT => {2609 2610 2611 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2612 collection_limits.sponsor_transfer_timeout2613 } else {2614 ChainLimit::get().nft_sponsor_transfer_timeout2615 };2616 2617 let mut sponsored = true;2618 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2619 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2620 let limit_time = last_tx_block + limit.into();2621 if block_number <= limit_time {2622 sponsored = false;2623 }2624 }2625 if sponsored {2626 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2627 }26282629 sponsored2630 }2631 CollectionMode::Fungible(_) => {2632 2633 2634 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2635 collection_limits.sponsor_transfer_timeout2636 } else {2637 ChainLimit::get().fungible_sponsor_transfer_timeout2638 };2639 2640 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2641 let mut sponsored = true;2642 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2643 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2644 let limit_time = last_tx_block + limit.into();2645 if block_number <= limit_time {2646 sponsored = false;2647 }2648 }2649 if sponsored {2650 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2651 }26522653 sponsored2654 }2655 CollectionMode::ReFungible => {2656 2657 2658 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2659 collection_limits.sponsor_transfer_timeout2660 } else {2661 ChainLimit::get().refungible_sponsor_transfer_timeout2662 };2663 2664 let mut sponsored = true;2665 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2666 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2667 let limit_time = last_tx_block + limit.into();2668 if block_number <= limit_time {2669 sponsored = false;2670 }2671 }2672 if sponsored {2673 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2674 }26752676 sponsored2677 }2678 _ => {2679 false2680 },2681 };2682 }26832684 if !sponsor_transfer {2685 T::AccountId::default()2686 } else {2687 <Collection<T>>::get(collection_id).sponsorship.sponsor()2688 .cloned()2689 .unwrap_or_default()2690 }2691 }26922693 _ => T::AccountId::default(),2694 };26952696 2697 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26982699 2700 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27012702 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2703 &who,2704 code_hash,2705 salt,2706 );2707 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27082709 T::AccountId::default()2710 },27112712 2713 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27142715 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2716 &who,2717 &T::Hashing::hash(&_code),2718 _salt,2719 );27202721 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27222723 T::AccountId::default()2724 }27252726 2727 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27282729 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27302731 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2732 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2733 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2734 2735 if !owned_contract && white_list_enabled {2736 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2737 return Err(InvalidTransaction::Call.into());2738 }2739 }27402741 let mut sponsor_transfer = false;2742 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2743 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2744 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2745 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2746 let limit_time = last_tx_block + rate_limit;27472748 if block_number >= limit_time {2749 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2750 sponsor_transfer = true;2751 }2752 } else {2753 sponsor_transfer = false;2754 }2755 2756 2757 let mut sp = T::AccountId::default();2758 if sponsor_transfer {2759 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2760 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2761 sp = called_contract;2762 }2763 }2764 }27652766 sp2767 },27682769 _ => sponsor,2770 };27712772 let mut who_pays_fee: T::AccountId = sponsor.clone();2773 if sponsor == T::AccountId::default() {2774 who_pays_fee = who.clone();2775 }27762777 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2778 .map(|i| (fee, i))2779 }2780}278127822783impl<T: Config + Send + Sync> SignedExtension2784 for ChargeTransactionPayment<T>2785where2786 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2787 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2788 T::AccountId: AsRef<[u8]>,2789 T::AccountId: UncheckedFrom<T::Hash>,2790{2791 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2792 type AccountId = T::AccountId;2793 type Call = T::Call;2794 type AdditionalSigned = ();2795 type Pre = (2796 2797 BalanceOf<T>,2798 2799 Self::AccountId,2800 2801 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2802 );2803 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2804 Ok(())2805 }28062807 fn validate(2808 &self,2809 who: &Self::AccountId,2810 call: &Self::Call,2811 info: &DispatchInfoOf<Self::Call>,2812 len: usize,2813 ) -> TransactionValidity {2814 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2815 Ok(ValidTransaction {2816 priority: Self::get_priority(len, info, fee),2817 ..Default::default()2818 })2819 }28202821 fn pre_dispatch(2822 self,2823 who: &Self::AccountId,2824 call: &Self::Call,2825 info: &DispatchInfoOf<Self::Call>,2826 len: usize,2827 ) -> Result<Self::Pre, TransactionValidityError> {2828 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2829 Ok((self.0, who.clone(), imbalance))2830 }28312832 fn post_dispatch(2833 pre: Self::Pre,2834 info: &DispatchInfoOf<Self::Call>,2835 post_info: &PostDispatchInfoOf<Self::Call>,2836 len: usize,2837 _result: &DispatchResult,2838 ) -> Result<(), TransactionValidityError> {2839 let (tip, who, imbalance) = pre;2840 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2841 len as u32,2842 info,2843 post_info,2844 tip,2845 );2846 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2847 Ok(())2848 }2849}28502851