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,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 CollectionCreationPrice: Get<BalanceOf<Self>>;439}440441#[cfg(feature = "runtime-benchmarks")]442mod benchmarking;443444445446447448449450451452453454455456457458459460461462463464465466467468decl_storage! {469 trait Store for Module<T: Config> as Nft {470471 472 473 CreatedCollectionCount: u32;474 475 ChainVersion: u64;476 477 478 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;479 480481 482 pub ChainLimit get(fn chain_limit) config(): ChainLimits;483 484485 486 487 488 DestroyedCollectionCount: u32;489 490 491 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;492 493494 495 496 497 pub Collection get(fn collection) config(): map hasher(blake2_128_concat) CollectionId => CollectionType<T::AccountId>;498 499 500 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;501 502 503 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;504 505506 507 508 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;509510 511 512 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;513514 515 516 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;517 518 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;519 520 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;521 522523 524 525 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;526 527528 529 530 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;531 532 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;533 534 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;535 536 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;537 538539 540 541 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;542 543 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;544 545 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;546 547 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;548 549 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 550 551 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 552 553 }554 add_extra_genesis {555 build(|config: &GenesisConfig<T>| {556 557 for (_num, _c) in &config.collection {558 <Module<T>>::init_collection(_c);559 }560561 for (_num, _c, _i) in &config.nft_item_id {562 <Module<T>>::init_nft_token(*_c, _i);563 }564565 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {566 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);567 }568569 for (_num, _c, _i) in &config.refungible_item_id {570 <Module<T>>::init_refungible_token(*_c, _i);571 }572 })573 }574}575576decl_event!(577 pub enum Event<T>578 where579 AccountId = <T as system::Config>::AccountId,580 {581 582 583 584 585 586 587 588 589 590 Created(CollectionId, u8, AccountId),591592 593 594 595 596 597 598 599 600 601 ItemCreated(CollectionId, TokenId, AccountId),602603 604 605 606 607 608 609 610 ItemDestroyed(CollectionId, TokenId),611612 613 614 615 616 617 618 619 620 621 622 623 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),624 }625);626627decl_module! {628 pub struct Module<T: Config> for enum Call 629 where 630 origin: T::Origin631 {632 fn deposit_event() = default;633 type Error = Error<T>;634635 fn on_initialize(now: T::BlockNumber) -> Weight {636 0637 }638639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 #[weight = <T as Config>::WeightInfo::create_collection()]656 #[transactional]657 pub fn create_collection(origin,658 collection_name: Vec<u16>,659 collection_description: Vec<u16>,660 token_prefix: Vec<u8>,661 mode: CollectionMode) -> DispatchResult {662663 664 let who = ensure_signed(origin)?;665666 let decimal_points = match mode {667 CollectionMode::Fungible(points) => points,668 _ => 0669 };670671 let chain_limit = ChainLimit::get();672673 let created_count = CreatedCollectionCount::get();674 let destroyed_count = DestroyedCollectionCount::get();675676 677 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);678679 680 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);681 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);682 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);683 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);684685 686 let next_id = created_count687 .checked_add(1)688 .ok_or(Error::<T>::NumOverflow)?;689690 CreatedCollectionCount::put(next_id);691692 let limits = CollectionLimits {693 sponsored_data_size: chain_limit.custom_data_limit,694 ..Default::default()695 };696697 698 let new_collection = CollectionType {699 owner: who.clone(),700 name: collection_name,701 mode: mode.clone(),702 mint_mode: false,703 access: AccessMode::Normal,704 description: collection_description,705 decimal_points: decimal_points,706 token_prefix: token_prefix,707 offchain_schema: Vec::new(),708 schema_version: SchemaVersion::ImageURL,709 sponsorship: SponsorshipState::Disabled,710 variable_on_chain_schema: Vec::new(),711 const_on_chain_schema: Vec::new(),712 limits,713 };714715 716 <Collection<T>>::insert(next_id, new_collection);717718 719 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));720721 Ok(())722 }723724 725 726 727 728 729 730 731 732 733 #[weight = <T as Config>::WeightInfo::destroy_collection()]734 #[transactional]735 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {736737 let sender = ensure_signed(origin)?;738 Self::check_owner_permissions(collection_id, sender)?;739740 let target_collection = <Collection<T>>::get(collection_id);741 if !target_collection.limits.owner_can_destroy {742 fail!(Error::<T>::NoPermission);743 }744745 <AddressTokens<T>>::remove_prefix(collection_id);746 <Allowances<T>>::remove_prefix(collection_id);747 <Balance<T>>::remove_prefix(collection_id);748 <ItemListIndex>::remove(collection_id);749 <AdminList<T>>::remove(collection_id);750 <Collection<T>>::remove(collection_id);751 <WhiteList<T>>::remove_prefix(collection_id);752753 <NftItemList<T>>::remove_prefix(collection_id);754 <FungibleItemList<T>>::remove_prefix(collection_id);755 <ReFungibleItemList<T>>::remove_prefix(collection_id);756757 <NftTransferBasket<T>>::remove_prefix(collection_id);758 <FungibleTransferBasket<T>>::remove_prefix(collection_id);759 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);760761 DestroyedCollectionCount::put(DestroyedCollectionCount::get()762 .checked_add(1)763 .ok_or(Error::<T>::NumOverflow)?);764765 Ok(())766 }767768 769 770 771 772 773 774 775 776 777 778 779 780 #[weight = <T as Config>::WeightInfo::add_to_white_list()]781 #[transactional]782 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{783784 let sender = ensure_signed(origin)?;785 Self::check_owner_or_admin_permissions(collection_id, sender)?;786787 <WhiteList<T>>::insert(collection_id, address, true);788 789 Ok(())790 }791792 793 794 795 796 797 798 799 800 801 802 803 804 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]805 #[transactional]806 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{807808 let sender = ensure_signed(origin)?;809 Self::check_owner_or_admin_permissions(collection_id, sender)?;810811 <WhiteList<T>>::remove(collection_id, address);812813 Ok(())814 }815816 817 818 819 820 821 822 823 824 825 826 827 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]828 #[transactional]829 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult830 {831 let sender = ensure_signed(origin)?;832833 Self::check_owner_permissions(collection_id, sender)?;834 let mut target_collection = <Collection<T>>::get(collection_id);835 target_collection.access = mode;836 <Collection<T>>::insert(collection_id, target_collection);837838 Ok(())839 }840841 842 843 844 845 846 847 848 849 850 851 852 853 854 #[weight = <T as Config>::WeightInfo::set_mint_permission()]855 #[transactional]856 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult857 {858 let sender = ensure_signed(origin)?;859860 Self::check_owner_permissions(collection_id, sender)?;861 let mut target_collection = <Collection<T>>::get(collection_id);862 target_collection.mint_mode = mint_permission;863 <Collection<T>>::insert(collection_id, target_collection);864865 Ok(())866 }867868 869 870 871 872 873 874 875 876 877 878 879 #[weight = <T as Config>::WeightInfo::change_collection_owner()]880 #[transactional]881 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {882883 let sender = ensure_signed(origin)?;884 Self::check_owner_permissions(collection_id, sender)?;885 let mut target_collection = <Collection<T>>::get(collection_id);886 target_collection.owner = new_owner;887 <Collection<T>>::insert(collection_id, target_collection);888889 Ok(())890 }891892 893 894 895 896 897 898 899 900 901 902 903 904 905 #[weight = <T as Config>::WeightInfo::add_collection_admin()]906 #[transactional]907 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {908909 let sender = ensure_signed(origin)?;910 Self::check_owner_or_admin_permissions(collection_id, sender)?;911 let mut admin_arr: Vec<T::AccountId> = Vec::new();912913 if <AdminList<T>>::contains_key(collection_id)914 {915 admin_arr = <AdminList<T>>::get(collection_id);916 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);917 }918919 920 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);921922 admin_arr.push(new_admin_id);923 <AdminList<T>>::insert(collection_id, admin_arr);924925 Ok(())926 }927928 929 930 931 932 933 934 935 936 937 938 939 940 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]941 #[transactional]942 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {943944 let sender = ensure_signed(origin)?;945 Self::check_owner_or_admin_permissions(collection_id, sender)?;946 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);947948 let mut admin_arr = <AdminList<T>>::get(collection_id);949 admin_arr.retain(|i| *i != account_id);950 <AdminList<T>>::insert(collection_id, admin_arr);951952 Ok(())953 }954955 956 957 958 959 960 961 962 963 964 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]965 #[transactional]966 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {967968 let sender = ensure_signed(origin)?;969 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);970971 let mut target_collection = <Collection<T>>::get(collection_id);972 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);973974 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);975 <Collection<T>>::insert(collection_id, target_collection);976977 Ok(())978 }979980 981 982 983 984 985 986 987 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]988 #[transactional]989 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {990991 let sender = ensure_signed(origin)?;992 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);993994 let mut target_collection = <Collection<T>>::get(collection_id);995 ensure!(996 target_collection.sponsorship.pending_sponsor() == Some(&sender),997 Error::<T>::ConfirmUnsetSponsorFail998 );9991000 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1001 <Collection<T>>::insert(collection_id, target_collection);10021003 Ok(())1004 }10051006 1007 1008 1009 1010 1011 1012 1013 1014 1015 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1016 #[transactional]1017 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10181019 let sender = ensure_signed(origin)?;1020 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10211022 let mut target_collection = <Collection<T>>::get(collection_id);1023 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10241025 target_collection.sponsorship = SponsorshipState::Disabled;1026 <Collection<T>>::insert(collection_id, target_collection);10271028 Ok(())1029 }10301031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 10541055 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1056 #[transactional]1057 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10581059 let sender = ensure_signed(origin)?;10601061 Self::collection_exists(collection_id)?;10621063 let target_collection = <Collection<T>>::get(collection_id);10641065 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1066 Self::validate_create_item_args(&target_collection, &data)?;1067 Self::create_item_no_validation(collection_id, owner, data)?;10681069 Ok(())1070 }10711072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1091 .map(|data| { data.len() })1092 .sum())]1093 #[transactional]1094 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {10951096 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1097 let sender = ensure_signed(origin)?;10981099 Self::collection_exists(collection_id)?;1100 let target_collection = <Collection<T>>::get(collection_id);11011102 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11031104 for data in &items_data {1105 Self::validate_create_item_args(&target_collection, data)?;1106 }1107 for data in &items_data {1108 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1109 }11101111 Ok(())1112 }11131114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 #[weight = <T as Config>::WeightInfo::burn_item()]1128 #[transactional]1129 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11301131 let sender = ensure_signed(origin)?;1132 Self::collection_exists(collection_id)?;11331134 1135 let target_collection = <Collection<T>>::get(collection_id);1136 ensure!(1137 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1138 (1139 target_collection.limits.owner_can_transfer &&1140 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1141 ),1142 Error::<T>::NoPermission1143 );11441145 if target_collection.access == AccessMode::WhiteList {1146 Self::check_white_list(collection_id, &sender)?;1147 }11481149 match target_collection.mode1150 {1151 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1152 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1153 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1154 _ => ()1155 };11561157 1158 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11591160 Ok(())1161 }11621163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 #[weight = <T as Config>::WeightInfo::transfer()]1187 #[transactional]1188 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1189 let sender = ensure_signed(origin)?;1190 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1191 }11921193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 #[weight = <T as Config>::WeightInfo::approve()]1209 #[transactional]1210 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12111212 let sender = ensure_signed(origin)?;12131214 Self::collection_exists(collection_id)?;1215 Self::token_exists(collection_id, item_id, &sender)?;12161217 1218 let target_collection = <Collection<T>>::get(collection_id);1219 let allowance_limit = if target_collection.limits.owner_can_transfer &&1220 Self::is_owner_or_admin_permissions(1221 collection_id,1222 sender.clone(),1223 ) {1224 None1225 } else if let Some(amount) = Self::owned_amount(1226 sender.clone(),1227 collection_id,1228 item_id,1229 ) {1230 Some(amount)1231 } else {1232 fail!(Error::<T>::NoPermission);1233 };12341235 if target_collection.access == AccessMode::WhiteList {1236 Self::check_white_list(collection_id, &sender)?;1237 Self::check_white_list(collection_id, &spender)?;1238 }12391240 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1241 let mut allowance: u128 = amount;1242 if allowance_exists {1243 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1244 }1245 if let Some(limit) = allowance_limit {1246 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1247 }1248 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12491250 Ok(())1251 }1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 #[weight = <T as Config>::WeightInfo::transfer_from()]1273 #[transactional]1274 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12751276 let sender = ensure_signed(origin)?;1277 let mut appoved_transfer = false;12781279 1280 let mut approval: u128 = 0;1281 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1282 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1283 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1284 appoved_transfer = true;1285 }12861287 let target_collection = <Collection<T>>::get(collection_id);12881289 1290 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;12911292 1293 ensure!(1294 appoved_transfer || 1295 (1296 target_collection.limits.owner_can_transfer &&1297 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1298 ),1299 Error::<T>::NoPermission1300 );13011302 if target_collection.access == AccessMode::WhiteList {1303 Self::check_white_list(collection_id, &sender)?;1304 Self::check_white_list(collection_id, &recipient)?;1305 }13061307 1308 if approval.saturating_sub(value) > 0 {1309 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1310 }1311 else {1312 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1313 }13141315 match target_collection.mode1316 {1317 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1318 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1319 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1320 _ => ()1321 };13221323 Ok(())1324 }13251326 1327 13281329 1330 1331 1332 13331334 13351336 13371338 1339 13401341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1354 #[transactional]1355 pub fn set_variable_meta_data (1356 origin,1357 collection_id: CollectionId,1358 item_id: TokenId,1359 data: Vec<u8>1360 ) -> DispatchResult {1361 let sender = ensure_signed(origin)?;1362 1363 Self::collection_exists(collection_id)?;1364 Self::token_exists(collection_id, item_id, &sender)?;13651366 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13671368 1369 let target_collection = <Collection<T>>::get(collection_id);1370 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1371 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1372 Error::<T>::NoPermission);13731374 match target_collection.mode1375 {1376 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1377 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1378 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1379 _ => fail!(Error::<T>::UnexpectedCollectionType)1380 };13811382 Ok(())1383 }1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 #[weight = <T as Config>::WeightInfo::set_schema_version()]1400 #[transactional]1401 pub fn set_schema_version(1402 origin,1403 collection_id: CollectionId,1404 version: SchemaVersion1405 ) -> DispatchResult {1406 let sender = ensure_signed(origin)?;1407 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1408 let mut target_collection = <Collection<T>>::get(collection_id);1409 target_collection.schema_version = version;1410 <Collection<T>>::insert(collection_id, target_collection);14111412 Ok(())1413 }14141415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1428 #[transactional]1429 pub fn set_offchain_schema(1430 origin,1431 collection_id: CollectionId,1432 schema: Vec<u8>1433 ) -> DispatchResult {1434 let sender = ensure_signed(origin)?;1435 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14361437 1438 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14391440 let mut target_collection = <Collection<T>>::get(collection_id);1441 target_collection.offchain_schema = schema;1442 <Collection<T>>::insert(collection_id, target_collection);14431444 Ok(())1445 }14461447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1460 #[transactional]1461 pub fn set_const_on_chain_schema (1462 origin,1463 collection_id: CollectionId,1464 schema: Vec<u8>1465 ) -> DispatchResult {1466 let sender = ensure_signed(origin)?;1467 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14681469 1470 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14711472 let mut target_collection = <Collection<T>>::get(collection_id);1473 target_collection.const_on_chain_schema = schema;1474 <Collection<T>>::insert(collection_id, target_collection);14751476 Ok(())1477 }14781479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1492 #[transactional]1493 pub fn set_variable_on_chain_schema (1494 origin,1495 collection_id: CollectionId,1496 schema: Vec<u8>1497 ) -> DispatchResult {1498 let sender = ensure_signed(origin)?;1499 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;15001501 1502 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15031504 let mut target_collection = <Collection<T>>::get(collection_id);1505 target_collection.variable_on_chain_schema = schema;1506 <Collection<T>>::insert(collection_id, target_collection);15071508 Ok(())1509 }15101511 1512 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1513 #[transactional]1514 pub fn set_chain_limits(1515 origin,1516 limits: ChainLimits1517 ) -> DispatchResult {15181519 #[cfg(not(feature = "runtime-benchmarks"))]1520 ensure_root(origin)?;15211522 <ChainLimit>::put(limits);1523 Ok(())1524 }15251526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1538 #[transactional]1539 pub fn enable_contract_sponsoring(1540 origin,1541 contract_address: T::AccountId,1542 enable: bool1543 ) -> DispatchResult {15441545 let sender = ensure_signed(origin)?;15461547 #[cfg(feature = "runtime-benchmarks")]1548 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15491550 Self::ensure_contract_owned(sender, &contract_address)?;15511552 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1553 Ok(())1554 }15551556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1574 #[transactional]1575 pub fn set_contract_sponsoring_rate_limit(1576 origin,1577 contract_address: T::AccountId,1578 rate_limit: T::BlockNumber1579 ) -> DispatchResult {1580 let sender = ensure_signed(origin)?;15811582 #[cfg(feature = "runtime-benchmarks")]1583 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15841585 Self::ensure_contract_owned(sender, &contract_address)?;1586 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1587 Ok(())1588 }15891590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1602 #[transactional]1603 pub fn toggle_contract_white_list(1604 origin,1605 contract_address: T::AccountId,1606 enable: bool1607 ) -> DispatchResult {1608 let sender = ensure_signed(origin)?;16091610 #[cfg(feature = "runtime-benchmarks")]1611 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16121613 Self::ensure_contract_owned(sender, &contract_address)?;1614 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1615 Ok(())1616 }1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1630 #[transactional]1631 pub fn add_to_contract_white_list(1632 origin,1633 contract_address: T::AccountId,1634 account_address: T::AccountId1635 ) -> DispatchResult {1636 let sender = ensure_signed(origin)?;16371638 #[cfg(feature = "runtime-benchmarks")]1639 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1640 1641 Self::ensure_contract_owned(sender, &contract_address)?; 1642 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1643 Ok(())1644 }16451646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1658 #[transactional]1659 pub fn remove_from_contract_white_list(1660 origin,1661 contract_address: T::AccountId,1662 account_address: T::AccountId1663 ) -> 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 <ContractWhiteList<T>>::remove(contract_address, account_address);1671 Ok(())1672 }16731674 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1675 #[transactional]1676 pub fn set_collection_limits(1677 origin,1678 collection_id: u32,1679 new_limits: CollectionLimits,1680 ) -> DispatchResult {1681 let sender = ensure_signed(origin)?;1682 Self::check_owner_permissions(collection_id, sender.clone())?;1683 let mut target_collection = <Collection<T>>::get(collection_id);1684 let old_limits = target_collection.limits;1685 let chain_limits = ChainLimit::get();16861687 1688 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1689 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1690 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1691 Error::<T>::CollectionLimitBoundsExceeded);16921693 1694 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1695 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16961697 ensure!(1698 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1699 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1700 Error::<T>::OwnerPermissionsCantBeReverted,1701 );17021703 target_collection.limits = new_limits;1704 <Collection<T>>::insert(collection_id, target_collection);17051706 Ok(())1707 } 1708 }1709}17101711impl<T: Config> Module<T> {17121713 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17141715 let target_collection = <Collection<T>>::get(collection_id);17161717 1718 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17191720 1721 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1722 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1723 Error::<T>::NoPermission);17241725 if target_collection.access == AccessMode::WhiteList {1726 Self::check_white_list(collection_id, &sender)?;1727 Self::check_white_list(collection_id, &recipient)?;1728 }17291730 match target_collection.mode1731 {1732 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1733 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1734 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1735 _ => ()1736 };17371738 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17391740 Ok(())1741 }174217431744 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17451746 1747 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1748 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1749 1750 Ok(())1751 }17521753 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17541755 1756 let total_items: u32 = ItemListIndex::get(collection_id);1757 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1758 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1759 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17601761 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1762 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1763 Self::check_white_list(collection_id, owner)?;1764 Self::check_white_list(collection_id, sender)?;1765 }17661767 Ok(())1768 }17691770 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1771 match target_collection.mode1772 {1773 CollectionMode::NFT => {1774 if let CreateItemData::NFT(data) = data {1775 1776 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1777 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1778 } else {1779 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1780 }1781 },1782 CollectionMode::Fungible(_) => {1783 if let CreateItemData::Fungible(_) = data {1784 } else {1785 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1786 }1787 },1788 CollectionMode::ReFungible => {1789 if let CreateItemData::ReFungible(data) = data {17901791 1792 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1793 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);17941795 1796 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1797 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1798 } else {1799 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1800 }1801 },1802 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1803 };18041805 Ok(())1806 }18071808 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1809 match data1810 {1811 CreateItemData::NFT(data) => {1812 let item = NftItemType {1813 owner: owner.clone(),1814 const_data: data.const_data,1815 variable_data: data.variable_data1816 };18171818 Self::add_nft_item(collection_id, item)?;1819 },1820 CreateItemData::Fungible(data) => {1821 Self::add_fungible_item(collection_id, &owner, data.value)?;1822 },1823 CreateItemData::ReFungible(data) => {1824 let mut owner_list = Vec::new();1825 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18261827 let item = ReFungibleItemType {1828 owner: owner_list,1829 const_data: data.const_data,1830 variable_data: data.variable_data1831 };18321833 Self::add_refungible_item(collection_id, item)?;1834 }1835 };18361837 Ok(())1838 }18391840 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18411842 1843 let mut balance: u128 = 0;1844 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1845 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1846 } 18471848 1849 let item = FungibleItemType {1850 value: balance + value1851 };1852 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18531854 1855 let new_balance = <Balance<T>>::get(collection_id, owner)1856 .checked_add(value)1857 .ok_or(Error::<T>::NumOverflow)?;1858 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18591860 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1861 Ok(())1862 }18631864 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1865 let current_index = <ItemListIndex>::get(collection_id)1866 .checked_add(1)1867 .ok_or(Error::<T>::NumOverflow)?;1868 let itemcopy = item.clone();18691870 ensure!(1871 item.owner.len() == 1,1872 Error::<T>::BadCreateRefungibleCall,1873 );1874 let item_owner = item.owner.first().expect("only one owner is defined");18751876 let value = item_owner.fraction;1877 let owner = item_owner.owner.clone();18781879 Self::add_token_index(collection_id, current_index, &owner)?;18801881 <ItemListIndex>::insert(collection_id, current_index);1882 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18831884 1885 let new_balance = <Balance<T>>::get(collection_id, &owner)1886 .checked_add(value)1887 .ok_or(Error::<T>::NumOverflow)?;1888 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);18891890 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1891 Ok(())1892 }18931894 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1895 let current_index = <ItemListIndex>::get(collection_id)1896 .checked_add(1)1897 .ok_or(Error::<T>::NumOverflow)?;18981899 let item_owner = item.owner.clone();1900 Self::add_token_index(collection_id, current_index, &item.owner)?;19011902 <ItemListIndex>::insert(collection_id, current_index);1903 <NftItemList<T>>::insert(collection_id, current_index, item);19041905 1906 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1907 .checked_add(1)1908 .ok_or(Error::<T>::NumOverflow)?;1909 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19101911 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1912 Ok(())1913 }19141915 fn burn_refungible_item(1916 collection_id: CollectionId,1917 item_id: TokenId,1918 owner: &T::AccountId,1919 ) -> DispatchResult {1920 ensure!(1921 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1922 Error::<T>::TokenNotFound1923 );1924 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1925 let rft_balance = token1926 .owner1927 .iter()1928 .find(|&i| i.owner == *owner)1929 .ok_or(Error::<T>::TokenNotFound)?;1930 Self::remove_token_index(collection_id, item_id, owner)?;19311932 1933 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1934 .checked_sub(rft_balance.fraction)1935 .ok_or(Error::<T>::NumOverflow)?;1936 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19371938 1939 let index = token1940 .owner1941 .iter()1942 .position(|i| i.owner == *owner)1943 .expect("owned item is exists");1944 token.owner.remove(index);1945 let owner_count = token.owner.len();19461947 1948 if owner_count == 0 {1949 <ReFungibleItemList<T>>::remove(collection_id, item_id);1950 }1951 else {1952 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1953 }19541955 Ok(())1956 }19571958 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1959 ensure!(1960 <NftItemList<T>>::contains_key(collection_id, item_id),1961 Error::<T>::TokenNotFound1962 );1963 let item = <NftItemList<T>>::get(collection_id, item_id);1964 Self::remove_token_index(collection_id, item_id, &item.owner)?;19651966 1967 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1968 .checked_sub(1)1969 .ok_or(Error::<T>::NumOverflow)?;1970 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1971 <NftItemList<T>>::remove(collection_id, item_id);19721973 Ok(())1974 }19751976 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1977 ensure!(1978 <FungibleItemList<T>>::contains_key(collection_id, owner),1979 Error::<T>::TokenNotFound1980 );1981 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1982 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19831984 1985 let new_balance = <Balance<T>>::get(collection_id, owner)1986 .checked_sub(value)1987 .ok_or(Error::<T>::NumOverflow)?;1988 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19891990 if balance.value - value > 0 {1991 balance.value -= value;1992 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1993 }1994 else {1995 <FungibleItemList<T>>::remove(collection_id, owner);1996 }19971998 Ok(())1999 }20002001 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2002 ensure!(2003 <Collection<T>>::contains_key(collection_id),2004 Error::<T>::CollectionNotFound2005 );2006 Ok(())2007 }20082009 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2010 Self::collection_exists(collection_id)?;20112012 let target_collection = <Collection<T>>::get(collection_id);2013 ensure!(2014 subject == target_collection.owner,2015 Error::<T>::NoPermission2016 );20172018 Ok(())2019 }20202021 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2022 let target_collection = <Collection<T>>::get(collection_id);2023 let mut result: bool = subject == target_collection.owner;2024 let exists = <AdminList<T>>::contains_key(collection_id);20252026 if !result & exists {2027 if <AdminList<T>>::get(collection_id).contains(&subject) {2028 result = true2029 }2030 }20312032 result2033 }20342035 fn check_owner_or_admin_permissions(2036 collection_id: CollectionId,2037 subject: T::AccountId,2038 ) -> DispatchResult {2039 Self::collection_exists(collection_id)?;2040 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20412042 ensure!(2043 result,2044 Error::<T>::NoPermission2045 );2046 Ok(())2047 }20482049 fn owned_amount(2050 subject: T::AccountId,2051 collection_id: CollectionId,2052 item_id: TokenId,2053 ) -> Option<u128> {2054 let target_collection = <Collection<T>>::get(collection_id);20552056 match target_collection.mode {2057 CollectionMode::NFT => {2058 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2059 return Some(1)2060 }2061 None2062 },2063 CollectionMode::Fungible(_) => {2064 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2065 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2066 .value);2067 }2068 None2069 },2070 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2071 .owner2072 .iter()2073 .find(|i| i.owner == subject)2074 .map(|i| i.fraction),2075 CollectionMode::Invalid => None,2076 }2077 }20782079 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2080 let target_collection = <Collection<T>>::get(collection_id);20812082 match target_collection.mode {2083 CollectionMode::NFT => {2084 <NftItemList<T>>::get(collection_id, item_id).owner == subject2085 }2086 CollectionMode::Fungible(_) => {2087 <FungibleItemList<T>>::contains_key(collection_id, &subject)2088 }2089 CollectionMode::ReFungible => {2090 <ReFungibleItemList<T>>::get(collection_id, item_id)2091 .owner2092 .iter()2093 .any(|i| i.owner == subject)2094 }2095 CollectionMode::Invalid => false,2096 }2097 }20982099 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2100 let mes = Error::<T>::AddresNotInWhiteList;2101 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21022103 Ok(())2104 }21052106 2107 2108 fn token_exists(2109 collection_id: CollectionId,2110 item_id: TokenId,2111 owner: &T::AccountId2112 ) -> DispatchResult {2113 let target_collection = <Collection<T>>::get(collection_id);2114 let exists = match target_collection.mode2115 {2116 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2117 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2118 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2119 _ => false2120 };21212122 ensure!(exists == true, Error::<T>::TokenNotFound);2123 Ok(())2124 }21252126 fn transfer_fungible(2127 collection_id: CollectionId,2128 value: u128,2129 owner: &T::AccountId,2130 recipient: &T::AccountId,2131 ) -> DispatchResult {2132 Self::token_exists(collection_id, 0, owner)?;21332134 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2135 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21362137 2138 Self::add_fungible_item(collection_id, recipient, value)?;21392140 2141 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21422143 2144 if balance.value == value {2145 <FungibleItemList<T>>::remove(collection_id, owner);2146 }2147 else {2148 balance.value -= value;2149 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2150 }21512152 Ok(())2153 }21542155 fn transfer_refungible(2156 collection_id: CollectionId,2157 item_id: TokenId,2158 value: u128,2159 owner: T::AccountId,2160 new_owner: T::AccountId,2161 ) -> DispatchResult {2162 Self::token_exists(collection_id, item_id, &owner)?;21632164 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2165 let item = full_item2166 .owner2167 .iter()2168 .filter(|i| i.owner == owner)2169 .next()2170 .ok_or(Error::<T>::TokenNotFound)?;2171 let amount = item.fraction;21722173 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21742175 2176 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2177 .checked_sub(value)2178 .ok_or(Error::<T>::NumOverflow)?;2179 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21802181 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2182 .checked_add(value)2183 .ok_or(Error::<T>::NumOverflow)?;2184 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);21852186 let old_owner = item.owner.clone();2187 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21882189 2190 if amount == value && !new_owner_has_account {2191 2192 2193 let mut new_full_item = full_item.clone();2194 new_full_item2195 .owner2196 .iter_mut()2197 .find(|i| i.owner == owner)2198 .expect("old owner does present in refungible")2199 .owner = new_owner.clone();2200 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22012202 2203 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2204 } else {2205 let mut new_full_item = full_item.clone();2206 new_full_item2207 .owner2208 .iter_mut()2209 .find(|i| i.owner == owner)2210 .expect("old owner does present in refungible")2211 .fraction -= value;22122213 2214 if new_owner_has_account {2215 2216 new_full_item2217 .owner2218 .iter_mut()2219 .find(|i| i.owner == new_owner)2220 .expect("new owner has account")2221 .fraction += value;2222 } else {2223 2224 new_full_item.owner.push(Ownership {2225 owner: new_owner.clone(),2226 fraction: value,2227 });2228 Self::add_token_index(collection_id, item_id, &new_owner)?;2229 }22302231 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2232 }22332234 Ok(())2235 }22362237 fn transfer_nft(2238 collection_id: CollectionId,2239 item_id: TokenId,2240 sender: T::AccountId,2241 new_owner: T::AccountId,2242 ) -> DispatchResult {2243 Self::token_exists(collection_id, item_id, &sender)?;22442245 let mut item = <NftItemList<T>>::get(collection_id, item_id);22462247 ensure!(2248 sender == item.owner,2249 Error::<T>::MustBeTokenOwner2250 );22512252 2253 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2254 .checked_sub(1)2255 .ok_or(Error::<T>::NumOverflow)?;2256 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22572258 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2259 .checked_add(1)2260 .ok_or(Error::<T>::NumOverflow)?;2261 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22622263 2264 let old_owner = item.owner.clone();2265 item.owner = new_owner.clone();2266 <NftItemList<T>>::insert(collection_id, item_id, item);22672268 2269 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22702271 Ok(())2272 }2273 2274 fn set_re_fungible_variable_data(2275 collection_id: CollectionId,2276 item_id: TokenId,2277 data: Vec<u8>2278 ) -> DispatchResult {2279 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22802281 item.variable_data = data;22822283 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22842285 Ok(())2286 }22872288 fn set_nft_variable_data(2289 collection_id: CollectionId,2290 item_id: TokenId,2291 data: Vec<u8>2292 ) -> DispatchResult {2293 let mut item = <NftItemList<T>>::get(collection_id, item_id);2294 2295 item.variable_data = data;22962297 <NftItemList<T>>::insert(collection_id, item_id, item);2298 2299 Ok(())2300 }23012302 fn init_collection(item: &CollectionType<T::AccountId>) {2303 2304 assert!(2305 item.decimal_points <= MAX_DECIMAL_POINTS,2306 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2307 );2308 assert!(2309 item.name.len() <= 64,2310 "Collection name can not be longer than 63 char"2311 );2312 assert!(2313 item.name.len() <= 256,2314 "Collection description can not be longer than 255 char"2315 );2316 assert!(2317 item.token_prefix.len() <= 16,2318 "Token prefix can not be longer than 15 char"2319 );23202321 2322 let next_id = CreatedCollectionCount::get()2323 .checked_add(1)2324 .unwrap();23252326 CreatedCollectionCount::put(next_id);2327 }23282329 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2330 let current_index = <ItemListIndex>::get(collection_id)2331 .checked_add(1)2332 .unwrap();23332334 let item_owner = item.owner.clone();2335 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23362337 <ItemListIndex>::insert(collection_id, current_index);23382339 2340 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2341 .checked_add(1)2342 .unwrap();2343 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2344 }23452346 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2347 let current_index = <ItemListIndex>::get(collection_id)2348 .checked_add(1)2349 .unwrap();23502351 Self::add_token_index(collection_id, current_index, owner).unwrap();23522353 <ItemListIndex>::insert(collection_id, current_index);23542355 2356 let new_balance = <Balance<T>>::get(collection_id, owner)2357 .checked_add(item.value)2358 .unwrap();2359 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2360 }23612362 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2363 let current_index = <ItemListIndex>::get(collection_id)2364 .checked_add(1)2365 .unwrap();23662367 let value = item.owner.first().unwrap().fraction;2368 let owner = item.owner.first().unwrap().owner.clone();23692370 Self::add_token_index(collection_id, current_index, &owner).unwrap();23712372 <ItemListIndex>::insert(collection_id, current_index);23732374 2375 let new_balance = <Balance<T>>::get(collection_id, &owner)2376 .checked_add(value)2377 .unwrap();2378 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2379 }23802381 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23822383 2384 if <AccountItemCount<T>>::contains_key(owner) {23852386 2387 let count = <AccountItemCount<T>>::get(owner);2388 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);23892390 <AccountItemCount<T>>::insert(owner.clone(), count2391 .checked_add(1)2392 .ok_or(Error::<T>::NumOverflow)?);2393 }2394 else {2395 <AccountItemCount<T>>::insert(owner.clone(), 1);2396 }23972398 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2399 if list_exists {2400 let mut list = <AddressTokens<T>>::get(collection_id, owner);2401 let item_contains = list.contains(&item_index.clone());24022403 if !item_contains {2404 list.push(item_index.clone());2405 }24062407 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2408 } else {2409 let mut itm = Vec::new();2410 itm.push(item_index.clone());2411 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2412 }24132414 Ok(())2415 }24162417 fn remove_token_index(2418 collection_id: CollectionId,2419 item_index: TokenId,2420 owner: &T::AccountId,2421 ) -> DispatchResult {24222423 2424 <AccountItemCount<T>>::insert(owner.clone(), 2425 <AccountItemCount<T>>::get(owner)2426 .checked_sub(1)2427 .ok_or(Error::<T>::NumOverflow)?);242824292430 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2431 if list_exists {2432 let mut list = <AddressTokens<T>>::get(collection_id, owner);2433 let item_contains = list.contains(&item_index.clone());24342435 if item_contains {2436 list.retain(|&item| item != item_index);2437 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2438 }2439 }24402441 Ok(())2442 }24432444 fn move_token_index(2445 collection_id: CollectionId,2446 item_index: TokenId,2447 old_owner: &T::AccountId,2448 new_owner: &T::AccountId,2449 ) -> DispatchResult {2450 Self::remove_token_index(collection_id, item_index, old_owner)?;2451 Self::add_token_index(collection_id, item_index, new_owner)?;24522453 Ok(())2454 }2455 2456 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2457 if <ContractOwner<T>>::contains_key(contract.clone()) {2458 let owner = <ContractOwner<T>>::get(contract);2459 ensure!(account == owner, Error::<T>::NoPermission);2460 } else {2461 fail!(Error::<T>::NoPermission);2462 }24632464 Ok(())2465 }2466}2467246824692470247124722473pub type Multiplier = FixedU128;24742475type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2476247724782479#[derive(Encode, Decode, Clone, Eq, PartialEq)]2480pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24812482impl<T: Config + Send + Sync> sp_std::fmt::Debug 2483 for ChargeTransactionPayment<T>2484{2485 #[cfg(feature = "std")]2486 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2487 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2488 }2489 #[cfg(not(feature = "std"))]2490 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2491 Ok(())2492 }2493}24942495impl<T: Config> ChargeTransactionPayment<T>2496where2497 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2498 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2499 T::AccountId: AsRef<[u8]>,2500 T::AccountId: UncheckedFrom<T::Hash>,2501{2502 fn traditional_fee(2503 len: usize,2504 info: &DispatchInfoOf<T::Call>,2505 tip: BalanceOf<T>,2506 ) -> BalanceOf<T>2507 where2508 T::Call: Dispatchable<Info = DispatchInfo>,2509 {2510 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2511 }25122513 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2514 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2515 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2516 let len_saturation = max_block_length as u64 / (len as u64).max(1);2517 let coefficient: BalanceOf<T> = weight_saturation2518 .min(len_saturation)2519 .saturated_into::<BalanceOf<T>>();2520 final_fee2521 .saturating_mul(coefficient)2522 .saturated_into::<TransactionPriority>()2523 }25242525 fn withdraw_fee(2526 &self,2527 who: &T::AccountId,2528 call: &T::Call,2529 info: &DispatchInfoOf<T::Call>,2530 len: usize,2531 ) -> Result<2532 (2533 BalanceOf<T>,2534 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2535 ),2536 TransactionValidityError,2537 > {2538 let tip = self.0;25392540 let fee = match call.is_sub_type() {2541 Some(Call::create_collection(..)) => T::CollectionCreationPrice::get(),2542 _ => Self::traditional_fee(len, info, tip),2543 };25442545 2546 if fee.is_zero() {2547 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2548 .map(|i| (fee, i));2549 }25502551 2552 2553 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2554 Some(Call::create_item(collection_id, _owner, _properties)) => {25552556 2557 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25582559 let collection = <Collection<T>>::get(collection_id);25602561 let limit = collection.limits.sponsor_transfer_timeout;2562 let mut sponsored = true;2563 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2564 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2565 let limit_time = last_tx_block + limit.into();2566 if block_number <= limit_time {2567 sponsored = false;2568 }2569 }2570 if sponsored {2571 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2572 }25732574 2575 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2576 (sponsored)2577 {2578 collection.sponsorship.sponsor()2579 .cloned()2580 .unwrap_or_default()2581 } else {2582 T::AccountId::default()2583 }2584 }2585 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2586 2587 let mut sponsor_transfer = false;2588 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {25892590 let collection_limits = <Collection<T>>::get(collection_id).limits;2591 let collection_mode = <Collection<T>>::get(collection_id).mode;2592 2593 2594 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2595 sponsor_transfer = match collection_mode {2596 CollectionMode::NFT => {2597 2598 2599 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2600 collection_limits.sponsor_transfer_timeout2601 } else {2602 ChainLimit::get().nft_sponsor_transfer_timeout2603 };2604 2605 let mut sponsored = true;2606 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2607 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2608 let limit_time = last_tx_block + limit.into();2609 if block_number <= limit_time {2610 sponsored = false;2611 }2612 }2613 if sponsored {2614 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2615 }26162617 sponsored2618 }2619 CollectionMode::Fungible(_) => {2620 2621 2622 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2623 collection_limits.sponsor_transfer_timeout2624 } else {2625 ChainLimit::get().fungible_sponsor_transfer_timeout2626 };2627 2628 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2629 let mut sponsored = true;2630 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2631 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2632 let limit_time = last_tx_block + limit.into();2633 if block_number <= limit_time {2634 sponsored = false;2635 }2636 }2637 if sponsored {2638 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2639 }26402641 sponsored2642 }2643 CollectionMode::ReFungible => {2644 2645 2646 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2647 collection_limits.sponsor_transfer_timeout2648 } else {2649 ChainLimit::get().refungible_sponsor_transfer_timeout2650 };2651 2652 let mut sponsored = true;2653 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2654 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2655 let limit_time = last_tx_block + limit.into();2656 if block_number <= limit_time {2657 sponsored = false;2658 }2659 }2660 if sponsored {2661 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2662 }26632664 sponsored2665 }2666 _ => {2667 false2668 },2669 };2670 }26712672 if !sponsor_transfer {2673 T::AccountId::default()2674 } else {2675 <Collection<T>>::get(collection_id).sponsorship.sponsor()2676 .cloned()2677 .unwrap_or_default()2678 }2679 }26802681 _ => T::AccountId::default(),2682 };26832684 2685 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26862687 2688 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {26892690 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2691 &who,2692 code_hash,2693 salt,2694 );2695 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());26962697 T::AccountId::default()2698 },26992700 2701 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27022703 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2704 &who,2705 &T::Hashing::hash(&_code),2706 _salt,2707 );27082709 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27102711 T::AccountId::default()2712 }27132714 2715 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27162717 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27182719 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2720 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2721 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2722 2723 if !owned_contract && white_list_enabled {2724 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2725 return Err(InvalidTransaction::Call.into());2726 }2727 }27282729 let mut sponsor_transfer = false;2730 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2731 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2732 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2733 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2734 let limit_time = last_tx_block + rate_limit;27352736 if block_number >= limit_time {2737 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2738 sponsor_transfer = true;2739 }2740 } else {2741 sponsor_transfer = false;2742 }2743 2744 2745 let mut sp = T::AccountId::default();2746 if sponsor_transfer {2747 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2748 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2749 sp = called_contract;2750 }2751 }2752 }27532754 sp2755 },27562757 _ => sponsor,2758 };27592760 let mut who_pays_fee: T::AccountId = sponsor.clone();2761 if sponsor == T::AccountId::default() {2762 who_pays_fee = who.clone();2763 }27642765 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2766 .map(|i| (fee, i))2767 }2768}276927702771impl<T: Config + Send + Sync> SignedExtension2772 for ChargeTransactionPayment<T>2773where2774 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2775 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2776 T::AccountId: AsRef<[u8]>,2777 T::AccountId: UncheckedFrom<T::Hash>,2778{2779 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2780 type AccountId = T::AccountId;2781 type Call = T::Call;2782 type AdditionalSigned = ();2783 type Pre = (2784 2785 BalanceOf<T>,2786 2787 Self::AccountId,2788 2789 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2790 );2791 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2792 Ok(())2793 }27942795 fn validate(2796 &self,2797 who: &Self::AccountId,2798 call: &Self::Call,2799 info: &DispatchInfoOf<Self::Call>,2800 len: usize,2801 ) -> TransactionValidity {2802 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2803 Ok(ValidTransaction {2804 priority: Self::get_priority(len, info, fee),2805 ..Default::default()2806 })2807 }28082809 fn pre_dispatch(2810 self,2811 who: &Self::AccountId,2812 call: &Self::Call,2813 info: &DispatchInfoOf<Self::Call>,2814 len: usize,2815 ) -> Result<Self::Pre, TransactionValidityError> {2816 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2817 Ok((self.0, who.clone(), imbalance))2818 }28192820 fn post_dispatch(2821 pre: Self::Pre,2822 info: &DispatchInfoOf<Self::Call>,2823 post_info: &PostDispatchInfoOf<Self::Call>,2824 len: usize,2825 _result: &DispatchResult,2826 ) -> Result<(), TransactionValidityError> {2827 let (tip, who, imbalance) = pre;2828 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2829 len as u32,2830 info,2831 post_info,2832 tip,2833 );2834 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2835 Ok(())2836 }2837}28382839