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 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();669 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(670 &T::TreasuryAccountId::get(),671 T::CollectionCreationPrice::get(),672 ));673 <T as Config>::Currency::settle(674 &who,675 imbalance,676 WithdrawReasons::TRANSFER,677 ExistenceRequirement::KeepAlive,678 ).map_err(|_| Error::<T>::NoPermission)?;679680 let decimal_points = match mode {681 CollectionMode::Fungible(points) => points,682 _ => 0683 };684685 let chain_limit = ChainLimit::get();686687 let created_count = CreatedCollectionCount::get();688 let destroyed_count = DestroyedCollectionCount::get();689690 691 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);692693 694 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);695 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);696 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);697 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);698699 700 let next_id = created_count701 .checked_add(1)702 .ok_or(Error::<T>::NumOverflow)?;703704 CreatedCollectionCount::put(next_id);705706 let limits = CollectionLimits {707 sponsored_data_size: chain_limit.custom_data_limit,708 ..Default::default()709 };710711 712 let new_collection = CollectionType {713 owner: who.clone(),714 name: collection_name,715 mode: mode.clone(),716 mint_mode: false,717 access: AccessMode::Normal,718 description: collection_description,719 decimal_points: decimal_points,720 token_prefix: token_prefix,721 offchain_schema: Vec::new(),722 schema_version: SchemaVersion::ImageURL,723 sponsorship: SponsorshipState::Disabled,724 variable_on_chain_schema: Vec::new(),725 const_on_chain_schema: Vec::new(),726 limits,727 };728729 730 <Collection<T>>::insert(next_id, new_collection);731732 733 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));734735 Ok(())736 }737738 739 740 741 742 743 744 745 746 747 #[weight = <T as Config>::WeightInfo::destroy_collection()]748 #[transactional]749 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {750751 let sender = ensure_signed(origin)?;752 Self::check_owner_permissions(collection_id, sender)?;753754 let target_collection = <Collection<T>>::get(collection_id);755 if !target_collection.limits.owner_can_destroy {756 fail!(Error::<T>::NoPermission);757 }758759 <AddressTokens<T>>::remove_prefix(collection_id);760 <Allowances<T>>::remove_prefix(collection_id);761 <Balance<T>>::remove_prefix(collection_id);762 <ItemListIndex>::remove(collection_id);763 <AdminList<T>>::remove(collection_id);764 <Collection<T>>::remove(collection_id);765 <WhiteList<T>>::remove_prefix(collection_id);766767 <NftItemList<T>>::remove_prefix(collection_id);768 <FungibleItemList<T>>::remove_prefix(collection_id);769 <ReFungibleItemList<T>>::remove_prefix(collection_id);770771 <NftTransferBasket<T>>::remove_prefix(collection_id);772 <FungibleTransferBasket<T>>::remove_prefix(collection_id);773 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);774775 DestroyedCollectionCount::put(DestroyedCollectionCount::get()776 .checked_add(1)777 .ok_or(Error::<T>::NumOverflow)?);778779 Ok(())780 }781782 783 784 785 786 787 788 789 790 791 792 793 794 #[weight = <T as Config>::WeightInfo::add_to_white_list()]795 #[transactional]796 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{797798 let sender = ensure_signed(origin)?;799 Self::check_owner_or_admin_permissions(collection_id, sender)?;800801 <WhiteList<T>>::insert(collection_id, address, true);802 803 Ok(())804 }805806 807 808 809 810 811 812 813 814 815 816 817 818 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]819 #[transactional]820 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{821822 let sender = ensure_signed(origin)?;823 Self::check_owner_or_admin_permissions(collection_id, sender)?;824825 <WhiteList<T>>::remove(collection_id, address);826827 Ok(())828 }829830 831 832 833 834 835 836 837 838 839 840 841 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]842 #[transactional]843 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult844 {845 let sender = ensure_signed(origin)?;846847 Self::check_owner_permissions(collection_id, sender)?;848 let mut target_collection = <Collection<T>>::get(collection_id);849 target_collection.access = mode;850 <Collection<T>>::insert(collection_id, target_collection);851852 Ok(())853 }854855 856 857 858 859 860 861 862 863 864 865 866 867 868 #[weight = <T as Config>::WeightInfo::set_mint_permission()]869 #[transactional]870 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult871 {872 let sender = ensure_signed(origin)?;873874 Self::check_owner_permissions(collection_id, sender)?;875 let mut target_collection = <Collection<T>>::get(collection_id);876 target_collection.mint_mode = mint_permission;877 <Collection<T>>::insert(collection_id, target_collection);878879 Ok(())880 }881882 883 884 885 886 887 888 889 890 891 892 893 #[weight = <T as Config>::WeightInfo::change_collection_owner()]894 #[transactional]895 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {896897 let sender = ensure_signed(origin)?;898 Self::check_owner_permissions(collection_id, sender)?;899 let mut target_collection = <Collection<T>>::get(collection_id);900 target_collection.owner = new_owner;901 <Collection<T>>::insert(collection_id, target_collection);902903 Ok(())904 }905906 907 908 909 910 911 912 913 914 915 916 917 918 919 #[weight = <T as Config>::WeightInfo::add_collection_admin()]920 #[transactional]921 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {922923 let sender = ensure_signed(origin)?;924 Self::check_owner_or_admin_permissions(collection_id, sender)?;925 let mut admin_arr: Vec<T::AccountId> = Vec::new();926927 if <AdminList<T>>::contains_key(collection_id)928 {929 admin_arr = <AdminList<T>>::get(collection_id);930 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);931 }932933 934 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);935936 admin_arr.push(new_admin_id);937 <AdminList<T>>::insert(collection_id, admin_arr);938939 Ok(())940 }941942 943 944 945 946 947 948 949 950 951 952 953 954 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]955 #[transactional]956 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {957958 let sender = ensure_signed(origin)?;959 Self::check_owner_or_admin_permissions(collection_id, sender)?;960 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);961962 let mut admin_arr = <AdminList<T>>::get(collection_id);963 admin_arr.retain(|i| *i != account_id);964 <AdminList<T>>::insert(collection_id, admin_arr);965966 Ok(())967 }968969 970 971 972 973 974 975 976 977 978 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]979 #[transactional]980 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {981982 let sender = ensure_signed(origin)?;983 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);984985 let mut target_collection = <Collection<T>>::get(collection_id);986 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);987988 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);989 <Collection<T>>::insert(collection_id, target_collection);990991 Ok(())992 }993994 995 996 997 998 999 1000 1001 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1002 #[transactional]1003 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10041005 let sender = ensure_signed(origin)?;1006 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10071008 let mut target_collection = <Collection<T>>::get(collection_id);1009 ensure!(1010 target_collection.sponsorship.pending_sponsor() == Some(&sender),1011 Error::<T>::ConfirmUnsetSponsorFail1012 );10131014 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1015 <Collection<T>>::insert(collection_id, target_collection);10161017 Ok(())1018 }10191020 1021 1022 1023 1024 1025 1026 1027 1028 1029 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1030 #[transactional]1031 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10321033 let sender = ensure_signed(origin)?;1034 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10351036 let mut target_collection = <Collection<T>>::get(collection_id);1037 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10381039 target_collection.sponsorship = SponsorshipState::Disabled;1040 <Collection<T>>::insert(collection_id, target_collection);10411042 Ok(())1043 }10441045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 10681069 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1070 #[transactional]1071 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10721073 let sender = ensure_signed(origin)?;10741075 Self::collection_exists(collection_id)?;10761077 let target_collection = <Collection<T>>::get(collection_id);10781079 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1080 Self::validate_create_item_args(&target_collection, &data)?;1081 Self::create_item_no_validation(collection_id, owner, data)?;10821083 Ok(())1084 }10851086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1105 .map(|data| { data.len() })1106 .sum())]1107 #[transactional]1108 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11091110 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1111 let sender = ensure_signed(origin)?;11121113 Self::collection_exists(collection_id)?;1114 let target_collection = <Collection<T>>::get(collection_id);11151116 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11171118 for data in &items_data {1119 Self::validate_create_item_args(&target_collection, data)?;1120 }1121 for data in &items_data {1122 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1123 }11241125 Ok(())1126 }11271128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 #[weight = <T as Config>::WeightInfo::burn_item()]1142 #[transactional]1143 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11441145 let sender = ensure_signed(origin)?;1146 Self::collection_exists(collection_id)?;11471148 1149 let target_collection = <Collection<T>>::get(collection_id);1150 ensure!(1151 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1152 (1153 target_collection.limits.owner_can_transfer &&1154 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1155 ),1156 Error::<T>::NoPermission1157 );11581159 if target_collection.access == AccessMode::WhiteList {1160 Self::check_white_list(collection_id, &sender)?;1161 }11621163 match target_collection.mode1164 {1165 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1166 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1167 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1168 _ => ()1169 };11701171 1172 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11731174 Ok(())1175 }11761177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 #[weight = <T as Config>::WeightInfo::transfer()]1201 #[transactional]1202 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1203 let sender = ensure_signed(origin)?;1204 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1205 }12061207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 #[weight = <T as Config>::WeightInfo::approve()]1223 #[transactional]1224 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12251226 let sender = ensure_signed(origin)?;12271228 Self::collection_exists(collection_id)?;1229 Self::token_exists(collection_id, item_id, &sender)?;12301231 1232 let target_collection = <Collection<T>>::get(collection_id);1233 let allowance_limit = if target_collection.limits.owner_can_transfer &&1234 Self::is_owner_or_admin_permissions(1235 collection_id,1236 sender.clone(),1237 ) {1238 None1239 } else if let Some(amount) = Self::owned_amount(1240 sender.clone(),1241 collection_id,1242 item_id,1243 ) {1244 Some(amount)1245 } else {1246 fail!(Error::<T>::NoPermission);1247 };12481249 if target_collection.access == AccessMode::WhiteList {1250 Self::check_white_list(collection_id, &sender)?;1251 Self::check_white_list(collection_id, &spender)?;1252 }12531254 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1255 let mut allowance: u128 = amount;1256 if allowance_exists {1257 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1258 }1259 if let Some(limit) = allowance_limit {1260 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1261 }1262 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12631264 Ok(())1265 }1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 #[weight = <T as Config>::WeightInfo::transfer_from()]1287 #[transactional]1288 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12891290 let sender = ensure_signed(origin)?;1291 let mut appoved_transfer = false;12921293 1294 let mut approval: u128 = 0;1295 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1296 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1297 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1298 appoved_transfer = true;1299 }13001301 let target_collection = <Collection<T>>::get(collection_id);13021303 1304 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;13051306 1307 ensure!(1308 appoved_transfer || 1309 (1310 target_collection.limits.owner_can_transfer &&1311 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1312 ),1313 Error::<T>::NoPermission1314 );13151316 if target_collection.access == AccessMode::WhiteList {1317 Self::check_white_list(collection_id, &sender)?;1318 Self::check_white_list(collection_id, &recipient)?;1319 }13201321 1322 if approval.saturating_sub(value) > 0 {1323 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1324 }1325 else {1326 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1327 }13281329 match target_collection.mode1330 {1331 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1332 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1333 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1334 _ => ()1335 };13361337 Ok(())1338 }13391340 1341 13421343 1344 1345 1346 13471348 13491350 13511352 1353 13541355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1368 #[transactional]1369 pub fn set_variable_meta_data (1370 origin,1371 collection_id: CollectionId,1372 item_id: TokenId,1373 data: Vec<u8>1374 ) -> DispatchResult {1375 let sender = ensure_signed(origin)?;1376 1377 Self::collection_exists(collection_id)?;1378 Self::token_exists(collection_id, item_id, &sender)?;13791380 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13811382 1383 let target_collection = <Collection<T>>::get(collection_id);1384 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1385 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1386 Error::<T>::NoPermission);13871388 match target_collection.mode1389 {1390 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1391 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1392 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1393 _ => fail!(Error::<T>::UnexpectedCollectionType)1394 };13951396 Ok(())1397 }1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 #[weight = <T as Config>::WeightInfo::set_schema_version()]1414 #[transactional]1415 pub fn set_schema_version(1416 origin,1417 collection_id: CollectionId,1418 version: SchemaVersion1419 ) -> DispatchResult {1420 let sender = ensure_signed(origin)?;1421 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1422 let mut target_collection = <Collection<T>>::get(collection_id);1423 target_collection.schema_version = version;1424 <Collection<T>>::insert(collection_id, target_collection);14251426 Ok(())1427 }14281429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1442 #[transactional]1443 pub fn set_offchain_schema(1444 origin,1445 collection_id: CollectionId,1446 schema: Vec<u8>1447 ) -> DispatchResult {1448 let sender = ensure_signed(origin)?;1449 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14501451 1452 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14531454 let mut target_collection = <Collection<T>>::get(collection_id);1455 target_collection.offchain_schema = schema;1456 <Collection<T>>::insert(collection_id, target_collection);14571458 Ok(())1459 }14601461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1474 #[transactional]1475 pub fn set_const_on_chain_schema (1476 origin,1477 collection_id: CollectionId,1478 schema: Vec<u8>1479 ) -> DispatchResult {1480 let sender = ensure_signed(origin)?;1481 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14821483 1484 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14851486 let mut target_collection = <Collection<T>>::get(collection_id);1487 target_collection.const_on_chain_schema = schema;1488 <Collection<T>>::insert(collection_id, target_collection);14891490 Ok(())1491 }14921493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1506 #[transactional]1507 pub fn set_variable_on_chain_schema (1508 origin,1509 collection_id: CollectionId,1510 schema: Vec<u8>1511 ) -> DispatchResult {1512 let sender = ensure_signed(origin)?;1513 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;15141515 1516 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15171518 let mut target_collection = <Collection<T>>::get(collection_id);1519 target_collection.variable_on_chain_schema = schema;1520 <Collection<T>>::insert(collection_id, target_collection);15211522 Ok(())1523 }15241525 1526 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1527 #[transactional]1528 pub fn set_chain_limits(1529 origin,1530 limits: ChainLimits1531 ) -> DispatchResult {15321533 #[cfg(not(feature = "runtime-benchmarks"))]1534 ensure_root(origin)?;15351536 <ChainLimit>::put(limits);1537 Ok(())1538 }15391540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1552 #[transactional]1553 pub fn enable_contract_sponsoring(1554 origin,1555 contract_address: T::AccountId,1556 enable: bool1557 ) -> DispatchResult {15581559 let sender = ensure_signed(origin)?;15601561 #[cfg(feature = "runtime-benchmarks")]1562 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15631564 Self::ensure_contract_owned(sender, &contract_address)?;15651566 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1567 Ok(())1568 }15691570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1588 #[transactional]1589 pub fn set_contract_sponsoring_rate_limit(1590 origin,1591 contract_address: T::AccountId,1592 rate_limit: T::BlockNumber1593 ) -> DispatchResult {1594 let sender = ensure_signed(origin)?;15951596 #[cfg(feature = "runtime-benchmarks")]1597 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15981599 Self::ensure_contract_owned(sender, &contract_address)?;1600 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1601 Ok(())1602 }16031604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1616 #[transactional]1617 pub fn toggle_contract_white_list(1618 origin,1619 contract_address: T::AccountId,1620 enable: bool1621 ) -> DispatchResult {1622 let sender = ensure_signed(origin)?;16231624 #[cfg(feature = "runtime-benchmarks")]1625 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16261627 Self::ensure_contract_owned(sender, &contract_address)?;1628 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1629 Ok(())1630 }1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1644 #[transactional]1645 pub fn add_to_contract_white_list(1646 origin,1647 contract_address: T::AccountId,1648 account_address: T::AccountId1649 ) -> DispatchResult {1650 let sender = ensure_signed(origin)?;16511652 #[cfg(feature = "runtime-benchmarks")]1653 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1654 1655 Self::ensure_contract_owned(sender, &contract_address)?; 1656 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1657 Ok(())1658 }16591660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1672 #[transactional]1673 pub fn remove_from_contract_white_list(1674 origin,1675 contract_address: T::AccountId,1676 account_address: T::AccountId1677 ) -> DispatchResult {1678 let sender = ensure_signed(origin)?;16791680 #[cfg(feature = "runtime-benchmarks")]1681 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16821683 Self::ensure_contract_owned(sender, &contract_address)?;1684 <ContractWhiteList<T>>::remove(contract_address, account_address);1685 Ok(())1686 }16871688 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1689 #[transactional]1690 pub fn set_collection_limits(1691 origin,1692 collection_id: u32,1693 new_limits: CollectionLimits,1694 ) -> DispatchResult {1695 let sender = ensure_signed(origin)?;1696 Self::check_owner_permissions(collection_id, sender.clone())?;1697 let mut target_collection = <Collection<T>>::get(collection_id);1698 let old_limits = target_collection.limits;1699 let chain_limits = ChainLimit::get();17001701 1702 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1703 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1704 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1705 Error::<T>::CollectionLimitBoundsExceeded);17061707 1708 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1709 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17101711 ensure!(1712 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1713 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1714 Error::<T>::OwnerPermissionsCantBeReverted,1715 );17161717 target_collection.limits = new_limits;1718 <Collection<T>>::insert(collection_id, target_collection);17191720 Ok(())1721 } 1722 }1723}17241725impl<T: Config> Module<T> {17261727 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17281729 let target_collection = <Collection<T>>::get(collection_id);17301731 1732 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17331734 1735 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1736 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1737 Error::<T>::NoPermission);17381739 if target_collection.access == AccessMode::WhiteList {1740 Self::check_white_list(collection_id, &sender)?;1741 Self::check_white_list(collection_id, &recipient)?;1742 }17431744 match target_collection.mode1745 {1746 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1747 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1748 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1749 _ => ()1750 };17511752 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17531754 Ok(())1755 }175617571758 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17591760 1761 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1762 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1763 1764 Ok(())1765 }17661767 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17681769 1770 let total_items: u32 = ItemListIndex::get(collection_id);1771 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1772 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1773 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17741775 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1776 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1777 Self::check_white_list(collection_id, owner)?;1778 Self::check_white_list(collection_id, sender)?;1779 }17801781 Ok(())1782 }17831784 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1785 match target_collection.mode1786 {1787 CollectionMode::NFT => {1788 if let CreateItemData::NFT(data) = data {1789 1790 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1791 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1792 } else {1793 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1794 }1795 },1796 CollectionMode::Fungible(_) => {1797 if let CreateItemData::Fungible(_) = data {1798 } else {1799 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1800 }1801 },1802 CollectionMode::ReFungible => {1803 if let CreateItemData::ReFungible(data) = data {18041805 1806 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1807 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18081809 1810 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1811 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1812 } else {1813 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1814 }1815 },1816 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1817 };18181819 Ok(())1820 }18211822 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1823 match data1824 {1825 CreateItemData::NFT(data) => {1826 let item = NftItemType {1827 owner: owner.clone(),1828 const_data: data.const_data,1829 variable_data: data.variable_data1830 };18311832 Self::add_nft_item(collection_id, item)?;1833 },1834 CreateItemData::Fungible(data) => {1835 Self::add_fungible_item(collection_id, &owner, data.value)?;1836 },1837 CreateItemData::ReFungible(data) => {1838 let mut owner_list = Vec::new();1839 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18401841 let item = ReFungibleItemType {1842 owner: owner_list,1843 const_data: data.const_data,1844 variable_data: data.variable_data1845 };18461847 Self::add_refungible_item(collection_id, item)?;1848 }1849 };18501851 Ok(())1852 }18531854 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18551856 1857 let mut balance: u128 = 0;1858 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1859 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1860 } 18611862 1863 let item = FungibleItemType {1864 value: balance + value1865 };1866 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18671868 1869 let new_balance = <Balance<T>>::get(collection_id, owner)1870 .checked_add(value)1871 .ok_or(Error::<T>::NumOverflow)?;1872 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18731874 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1875 Ok(())1876 }18771878 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1879 let current_index = <ItemListIndex>::get(collection_id)1880 .checked_add(1)1881 .ok_or(Error::<T>::NumOverflow)?;1882 let itemcopy = item.clone();18831884 ensure!(1885 item.owner.len() == 1,1886 Error::<T>::BadCreateRefungibleCall,1887 );1888 let item_owner = item.owner.first().expect("only one owner is defined");18891890 let value = item_owner.fraction;1891 let owner = item_owner.owner.clone();18921893 Self::add_token_index(collection_id, current_index, &owner)?;18941895 <ItemListIndex>::insert(collection_id, current_index);1896 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18971898 1899 let new_balance = <Balance<T>>::get(collection_id, &owner)1900 .checked_add(value)1901 .ok_or(Error::<T>::NumOverflow)?;1902 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19031904 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1905 Ok(())1906 }19071908 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1909 let current_index = <ItemListIndex>::get(collection_id)1910 .checked_add(1)1911 .ok_or(Error::<T>::NumOverflow)?;19121913 let item_owner = item.owner.clone();1914 Self::add_token_index(collection_id, current_index, &item.owner)?;19151916 <ItemListIndex>::insert(collection_id, current_index);1917 <NftItemList<T>>::insert(collection_id, current_index, item);19181919 1920 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1921 .checked_add(1)1922 .ok_or(Error::<T>::NumOverflow)?;1923 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19241925 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1926 Ok(())1927 }19281929 fn burn_refungible_item(1930 collection_id: CollectionId,1931 item_id: TokenId,1932 owner: &T::AccountId,1933 ) -> DispatchResult {1934 ensure!(1935 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1936 Error::<T>::TokenNotFound1937 );1938 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1939 let rft_balance = token1940 .owner1941 .iter()1942 .find(|&i| i.owner == *owner)1943 .ok_or(Error::<T>::TokenNotFound)?;1944 Self::remove_token_index(collection_id, item_id, owner)?;19451946 1947 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1948 .checked_sub(rft_balance.fraction)1949 .ok_or(Error::<T>::NumOverflow)?;1950 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19511952 1953 let index = token1954 .owner1955 .iter()1956 .position(|i| i.owner == *owner)1957 .expect("owned item is exists");1958 token.owner.remove(index);1959 let owner_count = token.owner.len();19601961 1962 if owner_count == 0 {1963 <ReFungibleItemList<T>>::remove(collection_id, item_id);1964 }1965 else {1966 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1967 }19681969 Ok(())1970 }19711972 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1973 ensure!(1974 <NftItemList<T>>::contains_key(collection_id, item_id),1975 Error::<T>::TokenNotFound1976 );1977 let item = <NftItemList<T>>::get(collection_id, item_id);1978 Self::remove_token_index(collection_id, item_id, &item.owner)?;19791980 1981 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1982 .checked_sub(1)1983 .ok_or(Error::<T>::NumOverflow)?;1984 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1985 <NftItemList<T>>::remove(collection_id, item_id);19861987 Ok(())1988 }19891990 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1991 ensure!(1992 <FungibleItemList<T>>::contains_key(collection_id, owner),1993 Error::<T>::TokenNotFound1994 );1995 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1996 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19971998 1999 let new_balance = <Balance<T>>::get(collection_id, owner)2000 .checked_sub(value)2001 .ok_or(Error::<T>::NumOverflow)?;2002 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20032004 if balance.value - value > 0 {2005 balance.value -= value;2006 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2007 }2008 else {2009 <FungibleItemList<T>>::remove(collection_id, owner);2010 }20112012 Ok(())2013 }20142015 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2016 ensure!(2017 <Collection<T>>::contains_key(collection_id),2018 Error::<T>::CollectionNotFound2019 );2020 Ok(())2021 }20222023 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2024 Self::collection_exists(collection_id)?;20252026 let target_collection = <Collection<T>>::get(collection_id);2027 ensure!(2028 subject == target_collection.owner,2029 Error::<T>::NoPermission2030 );20312032 Ok(())2033 }20342035 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2036 let target_collection = <Collection<T>>::get(collection_id);2037 let mut result: bool = subject == target_collection.owner;2038 let exists = <AdminList<T>>::contains_key(collection_id);20392040 if !result & exists {2041 if <AdminList<T>>::get(collection_id).contains(&subject) {2042 result = true2043 }2044 }20452046 result2047 }20482049 fn check_owner_or_admin_permissions(2050 collection_id: CollectionId,2051 subject: T::AccountId,2052 ) -> DispatchResult {2053 Self::collection_exists(collection_id)?;2054 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20552056 ensure!(2057 result,2058 Error::<T>::NoPermission2059 );2060 Ok(())2061 }20622063 fn owned_amount(2064 subject: T::AccountId,2065 collection_id: CollectionId,2066 item_id: TokenId,2067 ) -> Option<u128> {2068 let target_collection = <Collection<T>>::get(collection_id);20692070 match target_collection.mode {2071 CollectionMode::NFT => {2072 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2073 return Some(1)2074 }2075 None2076 },2077 CollectionMode::Fungible(_) => {2078 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2079 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2080 .value);2081 }2082 None2083 },2084 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2085 .owner2086 .iter()2087 .find(|i| i.owner == subject)2088 .map(|i| i.fraction),2089 CollectionMode::Invalid => None,2090 }2091 }20922093 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2094 let target_collection = <Collection<T>>::get(collection_id);20952096 match target_collection.mode {2097 CollectionMode::NFT => {2098 <NftItemList<T>>::get(collection_id, item_id).owner == subject2099 }2100 CollectionMode::Fungible(_) => {2101 <FungibleItemList<T>>::contains_key(collection_id, &subject)2102 }2103 CollectionMode::ReFungible => {2104 <ReFungibleItemList<T>>::get(collection_id, item_id)2105 .owner2106 .iter()2107 .any(|i| i.owner == subject)2108 }2109 CollectionMode::Invalid => false,2110 }2111 }21122113 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2114 let mes = Error::<T>::AddresNotInWhiteList;2115 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21162117 Ok(())2118 }21192120 2121 2122 fn token_exists(2123 collection_id: CollectionId,2124 item_id: TokenId,2125 owner: &T::AccountId2126 ) -> DispatchResult {2127 let target_collection = <Collection<T>>::get(collection_id);2128 let exists = match target_collection.mode2129 {2130 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2131 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2132 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2133 _ => false2134 };21352136 ensure!(exists == true, Error::<T>::TokenNotFound);2137 Ok(())2138 }21392140 fn transfer_fungible(2141 collection_id: CollectionId,2142 value: u128,2143 owner: &T::AccountId,2144 recipient: &T::AccountId,2145 ) -> DispatchResult {2146 Self::token_exists(collection_id, 0, owner)?;21472148 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2149 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21502151 2152 Self::add_fungible_item(collection_id, recipient, value)?;21532154 2155 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21562157 2158 if balance.value == value {2159 <FungibleItemList<T>>::remove(collection_id, owner);2160 }2161 else {2162 balance.value -= value;2163 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2164 }21652166 Ok(())2167 }21682169 fn transfer_refungible(2170 collection_id: CollectionId,2171 item_id: TokenId,2172 value: u128,2173 owner: T::AccountId,2174 new_owner: T::AccountId,2175 ) -> DispatchResult {2176 Self::token_exists(collection_id, item_id, &owner)?;21772178 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2179 let item = full_item2180 .owner2181 .iter()2182 .filter(|i| i.owner == owner)2183 .next()2184 .ok_or(Error::<T>::TokenNotFound)?;2185 let amount = item.fraction;21862187 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21882189 2190 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2191 .checked_sub(value)2192 .ok_or(Error::<T>::NumOverflow)?;2193 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21942195 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2196 .checked_add(value)2197 .ok_or(Error::<T>::NumOverflow)?;2198 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);21992200 let old_owner = item.owner.clone();2201 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22022203 2204 if amount == value && !new_owner_has_account {2205 2206 2207 let mut new_full_item = full_item.clone();2208 new_full_item2209 .owner2210 .iter_mut()2211 .find(|i| i.owner == owner)2212 .expect("old owner does present in refungible")2213 .owner = new_owner.clone();2214 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22152216 2217 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2218 } else {2219 let mut new_full_item = full_item.clone();2220 new_full_item2221 .owner2222 .iter_mut()2223 .find(|i| i.owner == owner)2224 .expect("old owner does present in refungible")2225 .fraction -= value;22262227 2228 if new_owner_has_account {2229 2230 new_full_item2231 .owner2232 .iter_mut()2233 .find(|i| i.owner == new_owner)2234 .expect("new owner has account")2235 .fraction += value;2236 } else {2237 2238 new_full_item.owner.push(Ownership {2239 owner: new_owner.clone(),2240 fraction: value,2241 });2242 Self::add_token_index(collection_id, item_id, &new_owner)?;2243 }22442245 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2246 }22472248 Ok(())2249 }22502251 fn transfer_nft(2252 collection_id: CollectionId,2253 item_id: TokenId,2254 sender: T::AccountId,2255 new_owner: T::AccountId,2256 ) -> DispatchResult {2257 Self::token_exists(collection_id, item_id, &sender)?;22582259 let mut item = <NftItemList<T>>::get(collection_id, item_id);22602261 ensure!(2262 sender == item.owner,2263 Error::<T>::MustBeTokenOwner2264 );22652266 2267 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2268 .checked_sub(1)2269 .ok_or(Error::<T>::NumOverflow)?;2270 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22712272 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2273 .checked_add(1)2274 .ok_or(Error::<T>::NumOverflow)?;2275 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22762277 2278 let old_owner = item.owner.clone();2279 item.owner = new_owner.clone();2280 <NftItemList<T>>::insert(collection_id, item_id, item);22812282 2283 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22842285 Ok(())2286 }2287 2288 fn set_re_fungible_variable_data(2289 collection_id: CollectionId,2290 item_id: TokenId,2291 data: Vec<u8>2292 ) -> DispatchResult {2293 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22942295 item.variable_data = data;22962297 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22982299 Ok(())2300 }23012302 fn set_nft_variable_data(2303 collection_id: CollectionId,2304 item_id: TokenId,2305 data: Vec<u8>2306 ) -> DispatchResult {2307 let mut item = <NftItemList<T>>::get(collection_id, item_id);2308 2309 item.variable_data = data;23102311 <NftItemList<T>>::insert(collection_id, item_id, item);2312 2313 Ok(())2314 }23152316 fn init_collection(item: &CollectionType<T::AccountId>) {2317 2318 assert!(2319 item.decimal_points <= MAX_DECIMAL_POINTS,2320 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2321 );2322 assert!(2323 item.name.len() <= 64,2324 "Collection name can not be longer than 63 char"2325 );2326 assert!(2327 item.name.len() <= 256,2328 "Collection description can not be longer than 255 char"2329 );2330 assert!(2331 item.token_prefix.len() <= 16,2332 "Token prefix can not be longer than 15 char"2333 );23342335 2336 let next_id = CreatedCollectionCount::get()2337 .checked_add(1)2338 .unwrap();23392340 CreatedCollectionCount::put(next_id);2341 }23422343 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2344 let current_index = <ItemListIndex>::get(collection_id)2345 .checked_add(1)2346 .unwrap();23472348 let item_owner = item.owner.clone();2349 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23502351 <ItemListIndex>::insert(collection_id, current_index);23522353 2354 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2355 .checked_add(1)2356 .unwrap();2357 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2358 }23592360 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2361 let current_index = <ItemListIndex>::get(collection_id)2362 .checked_add(1)2363 .unwrap();23642365 Self::add_token_index(collection_id, current_index, owner).unwrap();23662367 <ItemListIndex>::insert(collection_id, current_index);23682369 2370 let new_balance = <Balance<T>>::get(collection_id, owner)2371 .checked_add(item.value)2372 .unwrap();2373 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2374 }23752376 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2377 let current_index = <ItemListIndex>::get(collection_id)2378 .checked_add(1)2379 .unwrap();23802381 let value = item.owner.first().unwrap().fraction;2382 let owner = item.owner.first().unwrap().owner.clone();23832384 Self::add_token_index(collection_id, current_index, &owner).unwrap();23852386 <ItemListIndex>::insert(collection_id, current_index);23872388 2389 let new_balance = <Balance<T>>::get(collection_id, &owner)2390 .checked_add(value)2391 .unwrap();2392 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2393 }23942395 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23962397 2398 if <AccountItemCount<T>>::contains_key(owner) {23992400 2401 let count = <AccountItemCount<T>>::get(owner);2402 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24032404 <AccountItemCount<T>>::insert(owner.clone(), count2405 .checked_add(1)2406 .ok_or(Error::<T>::NumOverflow)?);2407 }2408 else {2409 <AccountItemCount<T>>::insert(owner.clone(), 1);2410 }24112412 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2413 if list_exists {2414 let mut list = <AddressTokens<T>>::get(collection_id, owner);2415 let item_contains = list.contains(&item_index.clone());24162417 if !item_contains {2418 list.push(item_index.clone());2419 }24202421 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2422 } else {2423 let mut itm = Vec::new();2424 itm.push(item_index.clone());2425 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2426 }24272428 Ok(())2429 }24302431 fn remove_token_index(2432 collection_id: CollectionId,2433 item_index: TokenId,2434 owner: &T::AccountId,2435 ) -> DispatchResult {24362437 2438 <AccountItemCount<T>>::insert(owner.clone(), 2439 <AccountItemCount<T>>::get(owner)2440 .checked_sub(1)2441 .ok_or(Error::<T>::NumOverflow)?);244224432444 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2445 if list_exists {2446 let mut list = <AddressTokens<T>>::get(collection_id, owner);2447 let item_contains = list.contains(&item_index.clone());24482449 if item_contains {2450 list.retain(|&item| item != item_index);2451 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2452 }2453 }24542455 Ok(())2456 }24572458 fn move_token_index(2459 collection_id: CollectionId,2460 item_index: TokenId,2461 old_owner: &T::AccountId,2462 new_owner: &T::AccountId,2463 ) -> DispatchResult {2464 Self::remove_token_index(collection_id, item_index, old_owner)?;2465 Self::add_token_index(collection_id, item_index, new_owner)?;24662467 Ok(())2468 }2469 2470 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2471 if <ContractOwner<T>>::contains_key(contract.clone()) {2472 let owner = <ContractOwner<T>>::get(contract);2473 ensure!(account == owner, Error::<T>::NoPermission);2474 } else {2475 fail!(Error::<T>::NoPermission);2476 }24772478 Ok(())2479 }2480}2481248224832484248524862487pub type Multiplier = FixedU128;24882489type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2490249124922493#[derive(Encode, Decode, Clone, Eq, PartialEq)]2494pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24952496impl<T: Config + Send + Sync> sp_std::fmt::Debug 2497 for ChargeTransactionPayment<T>2498{2499 #[cfg(feature = "std")]2500 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2501 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2502 }2503 #[cfg(not(feature = "std"))]2504 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2505 Ok(())2506 }2507}25082509impl<T: Config> ChargeTransactionPayment<T>2510where2511 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2512 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2513 T::AccountId: AsRef<[u8]>,2514 T::AccountId: UncheckedFrom<T::Hash>,2515{2516 fn traditional_fee(2517 len: usize,2518 info: &DispatchInfoOf<T::Call>,2519 tip: BalanceOf<T>,2520 ) -> BalanceOf<T>2521 where2522 T::Call: Dispatchable<Info = DispatchInfo>,2523 {2524 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2525 }25262527 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2528 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2529 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2530 let len_saturation = max_block_length as u64 / (len as u64).max(1);2531 let coefficient: BalanceOf<T> = weight_saturation2532 .min(len_saturation)2533 .saturated_into::<BalanceOf<T>>();2534 final_fee2535 .saturating_mul(coefficient)2536 .saturated_into::<TransactionPriority>()2537 }25382539 fn withdraw_fee(2540 &self,2541 who: &T::AccountId,2542 call: &T::Call,2543 info: &DispatchInfoOf<T::Call>,2544 len: usize,2545 ) -> Result<2546 (2547 BalanceOf<T>,2548 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2549 ),2550 TransactionValidityError,2551 > {2552 let tip = self.0;25532554 let fee = Self::traditional_fee(len, info, tip);25552556 2557 if fee.is_zero() {2558 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2559 .map(|i| (fee, i));2560 }25612562 2563 2564 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2565 Some(Call::create_item(collection_id, _owner, _properties)) => {25662567 2568 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25692570 let collection = <Collection<T>>::get(collection_id);25712572 let limit = collection.limits.sponsor_transfer_timeout;2573 let mut sponsored = true;2574 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2575 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2576 let limit_time = last_tx_block + limit.into();2577 if block_number <= limit_time {2578 sponsored = false;2579 }2580 }2581 if sponsored {2582 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2583 }25842585 2586 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2587 (sponsored)2588 {2589 collection.sponsorship.sponsor()2590 .cloned()2591 .unwrap_or_default()2592 } else {2593 T::AccountId::default()2594 }2595 }2596 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2597 2598 let mut sponsor_transfer = false;2599 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {26002601 let collection_limits = <Collection<T>>::get(collection_id).limits;2602 let collection_mode = <Collection<T>>::get(collection_id).mode;2603 2604 2605 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2606 sponsor_transfer = match collection_mode {2607 CollectionMode::NFT => {2608 2609 2610 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2611 collection_limits.sponsor_transfer_timeout2612 } else {2613 ChainLimit::get().nft_sponsor_transfer_timeout2614 };2615 2616 let mut sponsored = true;2617 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2618 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2619 let limit_time = last_tx_block + limit.into();2620 if block_number <= limit_time {2621 sponsored = false;2622 }2623 }2624 if sponsored {2625 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2626 }26272628 sponsored2629 }2630 CollectionMode::Fungible(_) => {2631 2632 2633 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2634 collection_limits.sponsor_transfer_timeout2635 } else {2636 ChainLimit::get().fungible_sponsor_transfer_timeout2637 };2638 2639 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2640 let mut sponsored = true;2641 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2642 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2643 let limit_time = last_tx_block + limit.into();2644 if block_number <= limit_time {2645 sponsored = false;2646 }2647 }2648 if sponsored {2649 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2650 }26512652 sponsored2653 }2654 CollectionMode::ReFungible => {2655 2656 2657 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2658 collection_limits.sponsor_transfer_timeout2659 } else {2660 ChainLimit::get().refungible_sponsor_transfer_timeout2661 };2662 2663 let mut sponsored = true;2664 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2665 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2666 let limit_time = last_tx_block + limit.into();2667 if block_number <= limit_time {2668 sponsored = false;2669 }2670 }2671 if sponsored {2672 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2673 }26742675 sponsored2676 }2677 _ => {2678 false2679 },2680 };2681 }26822683 if !sponsor_transfer {2684 T::AccountId::default()2685 } else {2686 <Collection<T>>::get(collection_id).sponsorship.sponsor()2687 .cloned()2688 .unwrap_or_default()2689 }2690 }26912692 _ => T::AccountId::default(),2693 };26942695 2696 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26972698 2699 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27002701 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2702 &who,2703 code_hash,2704 salt,2705 );2706 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27072708 T::AccountId::default()2709 },27102711 2712 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27132714 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2715 &who,2716 &T::Hashing::hash(&_code),2717 _salt,2718 );27192720 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27212722 T::AccountId::default()2723 }27242725 2726 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27272728 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27292730 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2731 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2732 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2733 2734 if !owned_contract && white_list_enabled {2735 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2736 return Err(InvalidTransaction::Call.into());2737 }2738 }27392740 let mut sponsor_transfer = false;2741 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2742 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2743 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2744 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2745 let limit_time = last_tx_block + rate_limit;27462747 if block_number >= limit_time {2748 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2749 sponsor_transfer = true;2750 }2751 } else {2752 sponsor_transfer = false;2753 }2754 2755 2756 let mut sp = T::AccountId::default();2757 if sponsor_transfer {2758 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2759 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2760 sp = called_contract;2761 }2762 }2763 }27642765 sp2766 },27672768 _ => sponsor,2769 };27702771 let mut who_pays_fee: T::AccountId = sponsor.clone();2772 if sponsor == T::AccountId::default() {2773 who_pays_fee = who.clone();2774 }27752776 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2777 .map(|i| (fee, i))2778 }2779}278027812782impl<T: Config + Send + Sync> SignedExtension2783 for ChargeTransactionPayment<T>2784where2785 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2786 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2787 T::AccountId: AsRef<[u8]>,2788 T::AccountId: UncheckedFrom<T::Hash>,2789{2790 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2791 type AccountId = T::AccountId;2792 type Call = T::Call;2793 type AdditionalSigned = ();2794 type Pre = (2795 2796 BalanceOf<T>,2797 2798 Self::AccountId,2799 2800 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2801 );2802 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2803 Ok(())2804 }28052806 fn validate(2807 &self,2808 who: &Self::AccountId,2809 call: &Self::Call,2810 info: &DispatchInfoOf<Self::Call>,2811 len: usize,2812 ) -> TransactionValidity {2813 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2814 Ok(ValidTransaction {2815 priority: Self::get_priority(len, info, fee),2816 ..Default::default()2817 })2818 }28192820 fn pre_dispatch(2821 self,2822 who: &Self::AccountId,2823 call: &Self::Call,2824 info: &DispatchInfoOf<Self::Call>,2825 len: usize,2826 ) -> Result<Self::Pre, TransactionValidityError> {2827 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2828 Ok((self.0, who.clone(), imbalance))2829 }28302831 fn post_dispatch(2832 pre: Self::Pre,2833 info: &DispatchInfoOf<Self::Call>,2834 post_info: &PostDispatchInfoOf<Self::Call>,2835 len: usize,2836 _result: &DispatchResult,2837 ) -> Result<(), TransactionValidityError> {2838 let (tip, who, imbalance) = pre;2839 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2840 len as u32,2841 info,2842 post_info,2843 tip,2844 );2845 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2846 Ok(())2847 }2848}28492850