123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue,32 transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38 traits::{39 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40 },41 transaction_validity::{42 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43 },44 FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263646566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73 Invalid,74 NFT,75 76 Fungible(DecimalPoints),77 ReFungible,78}7980impl Default for CollectionMode {81 fn default() -> Self {82 Self::Invalid83 }84}8586impl Into<u8> for CollectionMode {87 fn into(self) -> u8 {88 match self {89 CollectionMode::Invalid => 0,90 CollectionMode::NFT => 1,91 CollectionMode::Fungible(_) => 2,92 CollectionMode::ReFungible => 3,93 }94 }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100 Normal,101 WhiteList,102}103impl Default for AccessMode {104 fn default() -> Self {105 Self::Normal106 }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112 ImageURL,113 Unique,114}115impl Default for SchemaVersion {116 fn default() -> Self {117 Self::ImageURL118 }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124 pub owner: AccountId,125 pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131 132 Disabled,133 Unconfirmed(AccountId),134 135 Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139 fn sponsor(&self) -> Option<&AccountId> {140 match self {141 Self::Confirmed(sponsor) => Some(sponsor),142 _ => None,143 }144 }145146 fn pending_sponsor(&self) -> Option<&AccountId> {147 match self {148 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149 _ => None,150 }151 }152153 fn confirmed(&self) -> bool {154 matches!(self, Self::Confirmed(_))155 }156}157158impl<T> Default for SponsorshipState<T> {159 fn default() -> Self {160 Self::Disabled161 }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167 pub owner: T::AccountId,168 pub mode: CollectionMode,169 pub access: AccessMode,170 pub decimal_points: DecimalPoints,171 pub name: Vec<u16>, 172 pub description: Vec<u16>, 173 pub token_prefix: Vec<u8>, 174 pub mint_mode: bool,175 pub offchain_schema: Vec<u8>,176 pub schema_version: SchemaVersion,177 pub sponsorship: SponsorshipState<T::AccountId>,178 pub limits: CollectionLimits<T::BlockNumber>, 179 pub variable_on_chain_schema: Vec<u8>, 180 pub const_on_chain_schema: Vec<u8>, 181}182183pub struct CollectionHandle<T: Config> {184 pub id: CollectionId,185 collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189 type Target = Collection<T>;190191 fn deref(&self) -> &Self::Target {192 &self.collection193 }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197 fn deref_mut(&mut self) -> &mut Self::Target {198 &mut self.collection199 }200}201202#[derive(Encode, Decode, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205 pub owner: AccountId,206 pub const_data: Vec<u8>,207 pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213 pub value: u128,214}215216#[derive(Encode, Decode, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219 pub owner: Vec<Ownership<AccountId>>,220 pub const_data: Vec<u8>,221 pub variable_data: Vec<u8>,222}223224225226227228229230231232233234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238 pub account_token_ownership_limit: u32,239 pub sponsored_data_size: u32,240 241 242 243 pub sponsored_data_rate_limit: Option<BlockNumber>,244 pub token_limit: u32,245246 247 pub sponsor_transfer_timeout: u32,248 pub owner_can_transfer: bool,249 pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253 fn default() -> Self {254 Self { 255 account_token_ownership_limit: 10_000_000, 256 token_limit: u32::max_value(),257 sponsored_data_size: u32::MAX, 258 sponsored_data_rate_limit: None,259 sponsor_transfer_timeout: 14400,260 owner_can_transfer: true,261 owner_can_destroy: true262 }263 }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269 pub collection_numbers_limit: u32,270 pub account_token_ownership_limit: u32,271 pub collections_admins_limit: u64,272 pub custom_data_limit: u32,273274 275 pub nft_sponsor_transfer_timeout: u32,276 pub fungible_sponsor_transfer_timeout: u32,277 pub refungible_sponsor_transfer_timeout: u32,278279 280 pub offchain_schema_limit: u32,281 pub variable_on_chain_schema_limit: u32,282 pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286 fn create_collection() -> Weight;287 fn destroy_collection() -> Weight;288 fn add_to_white_list() -> Weight;289 fn remove_from_white_list() -> Weight;290 fn set_public_access_mode() -> Weight;291 fn set_mint_permission() -> Weight;292 fn change_collection_owner() -> Weight;293 fn add_collection_admin() -> Weight;294 fn remove_collection_admin() -> Weight;295 fn set_collection_sponsor() -> Weight;296 fn confirm_sponsorship() -> Weight;297 fn remove_collection_sponsor() -> Weight;298 fn create_item(s: usize) -> Weight;299 fn burn_item() -> Weight;300 fn transfer() -> Weight;301 fn approve() -> Weight;302 fn transfer_from() -> Weight;303 fn set_offchain_schema() -> Weight;304 fn set_const_on_chain_schema() -> Weight;305 fn set_variable_on_chain_schema() -> Weight;306 fn set_variable_meta_data() -> Weight;307 fn enable_contract_sponsoring() -> Weight;308 fn set_schema_version() -> Weight;309 fn set_chain_limits() -> Weight;310 fn set_contract_sponsoring_rate_limit() -> Weight;311 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312 fn toggle_contract_white_list() -> Weight;313 fn add_to_contract_white_list() -> Weight;314 fn remove_from_contract_white_list() -> Weight;315 fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321 pub const_data: Vec<u8>,322 pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328 pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334 pub const_data: Vec<u8>,335 pub variable_data: Vec<u8>,336 pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342 NFT(CreateNftData),343 Fungible(CreateFungibleData),344 ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348 pub fn len(&self) -> usize {349 let len = match self {350 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352 _ => 0353 };354 355 return len;356 }357}358359impl From<CreateNftData> for CreateItemData {360 fn from(item: CreateNftData) -> Self {361 CreateItemData::NFT(item)362 }363}364365impl From<CreateReFungibleData> for CreateItemData {366 fn from(item: CreateReFungibleData) -> Self {367 CreateItemData::ReFungible(item)368 }369}370371impl From<CreateFungibleData> for CreateItemData {372 fn from(item: CreateFungibleData) -> Self {373 CreateItemData::Fungible(item)374 }375}376377378decl_error! {379 380 pub enum Error for Module<T: Config> {381 382 TotalCollectionsLimitExceeded,383 384 CollectionDecimalPointLimitExceeded, 385 386 CollectionNameLimitExceeded, 387 388 CollectionDescriptionLimitExceeded, 389 390 CollectionTokenPrefixLimitExceeded,391 392 CollectionNotFound,393 394 TokenNotFound,395 396 AdminNotFound,397 398 NumOverflow, 399 400 AlreadyAdmin, 401 402 NoPermission,403 404 ConfirmUnsetSponsorFail,405 406 PublicMintingNotAllowed,407 408 MustBeTokenOwner,409 410 TokenValueTooLow,411 412 NftSizeLimitExceeded,413 414 ApproveNotFound,415 416 TokenValueNotEnough,417 418 ApproveRequired,419 420 AddresNotInWhiteList,421 422 CollectionAdminsLimitExceeded,423 424 AddressOwnershipLimitExceeded,425 426 EmptyArgument,427 428 TokenConstDataLimitExceeded,429 430 TokenVariableDataLimitExceeded,431 432 NotNftDataUsedToMintNftCollectionToken,433 434 NotFungibleDataUsedToMintFungibleCollectionToken,435 436 NotReFungibleDataUsedToMintReFungibleCollectionToken,437 438 UnexpectedCollectionType,439 440 CantStoreMetadataInFungibleTokens,441 442 CollectionTokenLimitExceeded,443 444 AccountTokenLimitExceeded,445 446 CollectionLimitBoundsExceeded,447 448 OwnerPermissionsCantBeReverted,449 450 SchemaDataLimitExceeded,451 452 WrongRefungiblePieces,453 454 BadCreateRefungibleCall,455 }456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461 462 type WeightInfo: WeightInfo;463464 type Currency: Currency<Self::AccountId>;465 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466 type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472473474475476477478479480481482483484485486487488489490491492493494495496decl_storage! {497 trait Store for Module<T: Config> as Nft {498499 500 501 CreatedCollectionCount: u32;502 503 ChainVersion: u64;504 505 506 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507 508509 510 pub ChainLimit get(fn chain_limit) config(): ChainLimits;511 512513 514 515 516 DestroyedCollectionCount: u32;517 518 519 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520 521522 523 524 525 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526 527 528 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529 530 531 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532 533534 535 536 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538 539 540 541 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543 544 545 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546 547 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548 549 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550 551552 553 554 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555 556557 558 559 560 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561 562 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563 564 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565 566 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567 568569 570 571 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572 573 574 575 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576 577 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578 579 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580 581 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582 583 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584 585 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586 587 }588 add_extra_genesis {589 build(|config: &GenesisConfig<T>| {590 591 for (_num, _c) in &config.collection_id {592 <Module<T>>::init_collection(_c);593 }594595 for (_num, _c, _i) in &config.nft_item_id {596 <Module<T>>::init_nft_token(*_c, _i);597 }598599 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601 }602603 for (_num, _c, _i) in &config.refungible_item_id {604 <Module<T>>::init_refungible_token(*_c, _i);605 }606 })607 }608}609610decl_event!(611 pub enum Event<T>612 where613 AccountId = <T as system::Config>::AccountId,614 {615 616 617 618 619 620 621 622 623 624 CollectionCreated(CollectionId, u8, AccountId),625626 627 628 629 630 631 632 633 634 635 ItemCreated(CollectionId, TokenId, AccountId),636637 638 639 640 641 642 643 644 ItemDestroyed(CollectionId, TokenId),645646 647 648 649 650 651 652 653 654 655 656 657 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659 660 661 662 663 664 665 666 667 668 Approved(CollectionId, TokenId, AccountId, AccountId, u128),669 }670);671672decl_module! {673 pub struct Module<T: Config> for enum Call 674 where 675 origin: T::Origin676 {677 fn deposit_event() = default;678 type Error = Error<T>;679680 fn on_initialize(now: T::BlockNumber) -> Weight {681 0682 }683684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 #[weight = <T as Config>::WeightInfo::create_collection()]701 #[transactional]702 pub fn create_collection(origin,703 collection_name: Vec<u16>,704 collection_description: Vec<u16>,705 token_prefix: Vec<u8>,706 mode: CollectionMode) -> DispatchResult {707708 709 let who = ensure_signed(origin)?;710711 712 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714 &T::TreasuryAccountId::get(),715 T::CollectionCreationPrice::get(),716 ));717 <T as Config>::Currency::settle(718 &who,719 imbalance,720 WithdrawReasons::TRANSFER,721 ExistenceRequirement::KeepAlive,722 ).map_err(|_| Error::<T>::NoPermission)?;723724 let decimal_points = match mode {725 CollectionMode::Fungible(points) => points,726 _ => 0727 };728729 let chain_limit = ChainLimit::get();730731 let created_count = CreatedCollectionCount::get();732 let destroyed_count = DestroyedCollectionCount::get();733734 735 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737 738 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743 744 let next_id = created_count745 .checked_add(1)746 .ok_or(Error::<T>::NumOverflow)?;747748 CreatedCollectionCount::put(next_id);749750 let limits = CollectionLimits {751 sponsored_data_size: chain_limit.custom_data_limit,752 ..Default::default()753 };754755 756 let new_collection = Collection {757 owner: who.clone(),758 name: collection_name,759 mode: mode.clone(),760 mint_mode: false,761 access: AccessMode::Normal,762 description: collection_description,763 decimal_points: decimal_points,764 token_prefix: token_prefix,765 offchain_schema: Vec::new(),766 schema_version: SchemaVersion::ImageURL,767 sponsorship: SponsorshipState::Disabled,768 variable_on_chain_schema: Vec::new(),769 const_on_chain_schema: Vec::new(),770 limits,771 };772773 774 <CollectionById<T>>::insert(next_id, new_collection);775776 777 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));778779 Ok(())780 }781782 783 784 785 786 787 788 789 790 791 #[weight = <T as Config>::WeightInfo::destroy_collection()]792 #[transactional]793 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795 let sender = ensure_signed(origin)?;796 let collection = Self::get_collection(collection_id)?;797 Self::check_owner_permissions(&collection, sender)?;798 if !collection.limits.owner_can_destroy {799 fail!(Error::<T>::NoPermission);800 }801802 <AddressTokens<T>>::remove_prefix(collection_id);803 <Allowances<T>>::remove_prefix(collection_id);804 <Balance<T>>::remove_prefix(collection_id);805 <ItemListIndex>::remove(collection_id);806 <AdminList<T>>::remove(collection_id);807 <CollectionById<T>>::remove(collection_id);808 <WhiteList<T>>::remove_prefix(collection_id);809810 <NftItemList<T>>::remove_prefix(collection_id);811 <FungibleItemList<T>>::remove_prefix(collection_id);812 <ReFungibleItemList<T>>::remove_prefix(collection_id);813814 <NftTransferBasket<T>>::remove_prefix(collection_id);815 <FungibleTransferBasket<T>>::remove_prefix(collection_id);816 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820 DestroyedCollectionCount::put(DestroyedCollectionCount::get()821 .checked_add(1)822 .ok_or(Error::<T>::NumOverflow)?);823824 Ok(())825 }826827 828 829 830 831 832 833 834 835 836 837 838 839 #[weight = <T as Config>::WeightInfo::add_to_white_list()]840 #[transactional]841 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843 let sender = ensure_signed(origin)?;844 let collection = Self::get_collection(collection_id)?;845 Self::check_owner_or_admin_permissions(&collection, sender)?;846847 <WhiteList<T>>::insert(collection_id, address, true);848 849 Ok(())850 }851852 853 854 855 856 857 858 859 860 861 862 863 864 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]865 #[transactional]866 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{867868 let sender = ensure_signed(origin)?;869 let collection = Self::get_collection(collection_id)?;870 Self::check_owner_or_admin_permissions(&collection, sender)?;871872 <WhiteList<T>>::remove(collection_id, address);873874 Ok(())875 }876877 878 879 880 881 882 883 884 885 886 887 888 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]889 #[transactional]890 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult891 {892 let sender = ensure_signed(origin)?;893894 let mut target_collection = Self::get_collection(collection_id)?;895 Self::check_owner_permissions(&target_collection, sender)?;896 target_collection.access = mode;897 Self::save_collection(target_collection);898899 Ok(())900 }901902 903 904 905 906 907 908 909 910 911 912 913 914 915 #[weight = <T as Config>::WeightInfo::set_mint_permission()]916 #[transactional]917 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult918 {919 let sender = ensure_signed(origin)?;920921 let mut target_collection = Self::get_collection(collection_id)?;922 Self::check_owner_permissions(&target_collection, sender)?;923 target_collection.mint_mode = mint_permission;924 Self::save_collection(target_collection);925926 Ok(())927 }928929 930 931 932 933 934 935 936 937 938 939 940 #[weight = <T as Config>::WeightInfo::change_collection_owner()]941 #[transactional]942 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {943944 let sender = ensure_signed(origin)?;945 let mut target_collection = Self::get_collection(collection_id)?;946 Self::check_owner_permissions(&target_collection, sender)?;947 target_collection.owner = new_owner;948 Self::save_collection(target_collection);949950 Ok(())951 }952953 954 955 956 957 958 959 960 961 962 963 964 965 966 #[weight = <T as Config>::WeightInfo::add_collection_admin()]967 #[transactional]968 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {969970 let sender = ensure_signed(origin)?;971 let collection = Self::get_collection(collection_id)?;972 Self::check_owner_or_admin_permissions(&collection, sender)?;973 let mut admin_arr = <AdminList<T>>::get(collection_id);974975 match admin_arr.binary_search(&new_admin_id) {976 Ok(_) => {},977 Err(idx) => {978 let limits = ChainLimit::get();979 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);980 admin_arr.insert(idx, new_admin_id);981 <AdminList<T>>::insert(collection_id, admin_arr);982 }983 }984 Ok(())985 }986987 988 989 990 991 992 993 994 995 996 997 998 999 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1000 #[transactional]1001 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10021003 let sender = ensure_signed(origin)?;1004 let collection = Self::get_collection(collection_id)?;1005 Self::check_owner_or_admin_permissions(&collection, sender)?;1006 let mut admin_arr = <AdminList<T>>::get(collection_id);10071008 match admin_arr.binary_search(&account_id) {1009 Ok(idx) => {1010 admin_arr.remove(idx);1011 <AdminList<T>>::insert(collection_id, admin_arr);1012 },1013 Err(_) => {}1014 }1015 Ok(())1016 }10171018 1019 1020 1021 1022 1023 1024 1025 1026 1027 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1028 #[transactional]1029 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10301031 let sender = ensure_signed(origin)?;1032 let mut target_collection = Self::get_collection(collection_id)?;1033 Self::check_owner_permissions(&target_collection, sender)?;10341035 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1036 Self::save_collection(target_collection);10371038 Ok(())1039 }10401041 1042 1043 1044 1045 1046 1047 1048 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1049 #[transactional]1050 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10511052 let sender = ensure_signed(origin)?;10531054 let mut target_collection = Self::get_collection(collection_id)?;1055 ensure!(1056 target_collection.sponsorship.pending_sponsor() == Some(&sender),1057 Error::<T>::ConfirmUnsetSponsorFail1058 );10591060 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1061 Self::save_collection(target_collection);10621063 Ok(())1064 }10651066 1067 1068 1069 1070 1071 1072 1073 1074 1075 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1076 #[transactional]1077 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10781079 let sender = ensure_signed(origin)?;10801081 let mut target_collection = Self::get_collection(collection_id)?;1082 Self::check_owner_permissions(&target_collection, sender)?;10831084 target_collection.sponsorship = SponsorshipState::Disabled;1085 Self::save_collection(target_collection);10861087 Ok(())1088 }10891090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 11131114 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1115 #[transactional]1116 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11171118 let sender = ensure_signed(origin)?;11191120 let target_collection = Self::get_collection(collection_id)?;11211122 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1123 Self::validate_create_item_args(&target_collection, &data)?;1124 Self::create_item_no_validation(&target_collection, owner, data)?;11251126 Ok(())1127 }11281129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148 .map(|data| { data.len() })1149 .sum())]1150 #[transactional]1151 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154 let sender = ensure_signed(origin)?;11551156 let target_collection = Self::get_collection(collection_id)?;11571158 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160 for data in &items_data {1161 Self::validate_create_item_args(&target_collection, data)?;1162 }1163 for data in &items_data {1164 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165 }11661167 Ok(())1168 }11691170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 #[weight = <T as Config>::WeightInfo::burn_item()]1184 #[transactional]1185 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187 let sender = ensure_signed(origin)?;11881189 1190 let target_collection = Self::get_collection(collection_id)?;1191 ensure!(1192 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193 (1194 target_collection.limits.owner_can_transfer &&1195 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196 ),1197 Error::<T>::NoPermission1198 );11991200 if target_collection.access == AccessMode::WhiteList {1201 Self::check_white_list(&target_collection, &sender)?;1202 }12031204 match target_collection.mode1205 {1206 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1208 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209 _ => ()1210 };12111212 1213 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215 Ok(())1216 }12171218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 #[weight = <T as Config>::WeightInfo::transfer()]1242 #[transactional]1243 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244 let sender = ensure_signed(origin)?;1245 let collection = Self::get_collection(collection_id)?;12461247 Self::transfer_internal(sender, recipient, &collection, item_id, value)1248 }12491250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 #[weight = <T as Config>::WeightInfo::approve()]1266 #[transactional]1267 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269 let sender = ensure_signed(origin)?;1270 let target_collection = Self::get_collection(collection_id)?;12711272 Self::token_exists(&target_collection, item_id)?;12731274 1275 let bypasses_limits = target_collection.limits.owner_can_transfer &&1276 Self::is_owner_or_admin_permissions(1277 &target_collection,1278 sender.clone(),1279 );12801281 let allowance_limit = if bypasses_limits {1282 None1283 } else if let Some(amount) = Self::owned_amount(1284 sender.clone(),1285 &target_collection,1286 item_id,1287 ) {1288 Some(amount)1289 } else {1290 fail!(Error::<T>::NoPermission);1291 };12921293 if target_collection.access == AccessMode::WhiteList {1294 Self::check_white_list(&target_collection, &sender)?;1295 Self::check_white_list(&target_collection, &spender)?;1296 }12971298 let allowance: u128 = amount1299 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1300 .ok_or(Error::<T>::NumOverflow)?;1301 if let Some(limit) = allowance_limit {1302 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1303 }1304 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13051306 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1307 Ok(())1308 }1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 #[weight = <T as Config>::WeightInfo::transfer_from()]1330 #[transactional]1331 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13321333 let sender = ensure_signed(origin)?;1334 let target_collection = Self::get_collection(collection_id)?;13351336 1337 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13381339 1340 Self::is_correct_transfer(&target_collection, &recipient)?;13411342 1343 ensure!(1344 approval >= value || 1345 (1346 target_collection.limits.owner_can_transfer &&1347 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1348 ),1349 Error::<T>::NoPermission1350 );13511352 if target_collection.access == AccessMode::WhiteList {1353 Self::check_white_list(&target_collection, &sender)?;1354 Self::check_white_list(&target_collection, &recipient)?;1355 }13561357 1358 if approval.saturating_sub(value) > 0 {1359 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1360 }1361 else {1362 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1363 }13641365 match target_collection.mode1366 {1367 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1368 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1369 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1370 _ => ()1371 };13721373 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1374 Ok(())1375 }13761377 1378 13791380 1381 1382 1383 13841385 13861387 13881389 1390 13911392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1405 #[transactional]1406 pub fn set_variable_meta_data (1407 origin,1408 collection_id: CollectionId,1409 item_id: TokenId,1410 data: Vec<u8>1411 ) -> DispatchResult {1412 let sender = ensure_signed(origin)?;1413 1414 let target_collection = Self::get_collection(collection_id)?;1415 Self::token_exists(&target_collection, item_id)?;14161417 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14181419 1420 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1421 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1422 Error::<T>::NoPermission);14231424 match target_collection.mode1425 {1426 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1427 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1428 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1429 _ => fail!(Error::<T>::UnexpectedCollectionType)1430 };14311432 Ok(())1433 }1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 #[weight = <T as Config>::WeightInfo::set_schema_version()]1450 #[transactional]1451 pub fn set_schema_version(1452 origin,1453 collection_id: CollectionId,1454 version: SchemaVersion1455 ) -> DispatchResult {1456 let sender = ensure_signed(origin)?;1457 let mut target_collection = Self::get_collection(collection_id)?;1458 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1459 target_collection.schema_version = version;1460 Self::save_collection(target_collection);14611462 Ok(())1463 }14641465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1478 #[transactional]1479 pub fn set_offchain_schema(1480 origin,1481 collection_id: CollectionId,1482 schema: Vec<u8>1483 ) -> DispatchResult {1484 let sender = ensure_signed(origin)?;1485 let mut target_collection = Self::get_collection(collection_id)?;1486 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14871488 1489 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14901491 target_collection.offchain_schema = schema;1492 Self::save_collection(target_collection);14931494 Ok(())1495 }14961497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1510 #[transactional]1511 pub fn set_const_on_chain_schema (1512 origin,1513 collection_id: CollectionId,1514 schema: Vec<u8>1515 ) -> DispatchResult {1516 let sender = ensure_signed(origin)?;1517 let mut target_collection = Self::get_collection(collection_id)?;1518 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15191520 1521 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15221523 target_collection.const_on_chain_schema = schema;1524 Self::save_collection(target_collection);15251526 Ok(())1527 }15281529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1542 #[transactional]1543 pub fn set_variable_on_chain_schema (1544 origin,1545 collection_id: CollectionId,1546 schema: Vec<u8>1547 ) -> DispatchResult {1548 let sender = ensure_signed(origin)?;1549 let mut target_collection = Self::get_collection(collection_id)?;1550 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15511552 1553 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15541555 target_collection.variable_on_chain_schema = schema;1556 Self::save_collection(target_collection);15571558 Ok(())1559 }15601561 1562 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1563 #[transactional]1564 pub fn set_chain_limits(1565 origin,1566 limits: ChainLimits1567 ) -> DispatchResult {15681569 #[cfg(not(feature = "runtime-benchmarks"))]1570 ensure_root(origin)?;15711572 <ChainLimit>::put(limits);1573 Ok(())1574 }15751576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1588 #[transactional]1589 pub fn enable_contract_sponsoring(1590 origin,1591 contract_address: T::AccountId,1592 enable: bool1593 ) -> DispatchResult {15941595 let sender = ensure_signed(origin)?;15961597 #[cfg(feature = "runtime-benchmarks")]1598 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15991600 Self::ensure_contract_owned(sender, &contract_address)?;16011602 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1603 Ok(())1604 }16051606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1624 #[transactional]1625 pub fn set_contract_sponsoring_rate_limit(1626 origin,1627 contract_address: T::AccountId,1628 rate_limit: T::BlockNumber1629 ) -> DispatchResult {1630 let sender = ensure_signed(origin)?;16311632 #[cfg(feature = "runtime-benchmarks")]1633 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16341635 Self::ensure_contract_owned(sender, &contract_address)?;1636 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1637 Ok(())1638 }16391640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1652 #[transactional]1653 pub fn toggle_contract_white_list(1654 origin,1655 contract_address: T::AccountId,1656 enable: bool1657 ) -> DispatchResult {1658 let sender = ensure_signed(origin)?;16591660 #[cfg(feature = "runtime-benchmarks")]1661 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16621663 Self::ensure_contract_owned(sender, &contract_address)?;1664 if enable {1665 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1666 } else {1667 <ContractWhiteListEnabled<T>>::remove(contract_address);1668 }1669 Ok(())1670 }1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1684 #[transactional]1685 pub fn add_to_contract_white_list(1686 origin,1687 contract_address: T::AccountId,1688 account_address: T::AccountId1689 ) -> DispatchResult {1690 let sender = ensure_signed(origin)?;16911692 #[cfg(feature = "runtime-benchmarks")]1693 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1694 1695 Self::ensure_contract_owned(sender, &contract_address)?; 1696 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1697 Ok(())1698 }16991700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1712 #[transactional]1713 pub fn remove_from_contract_white_list(1714 origin,1715 contract_address: T::AccountId,1716 account_address: T::AccountId1717 ) -> DispatchResult {1718 let sender = ensure_signed(origin)?;17191720 #[cfg(feature = "runtime-benchmarks")]1721 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17221723 Self::ensure_contract_owned(sender, &contract_address)?;1724 <ContractWhiteList<T>>::remove(contract_address, account_address);1725 Ok(())1726 }17271728 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1729 #[transactional]1730 pub fn set_collection_limits(1731 origin,1732 collection_id: u32,1733 new_limits: CollectionLimits<T::BlockNumber>,1734 ) -> DispatchResult {1735 let sender = ensure_signed(origin)?;1736 let mut target_collection = Self::get_collection(collection_id)?;1737 Self::check_owner_permissions(&target_collection, sender.clone())?;1738 let old_limits = &target_collection.limits;1739 let chain_limits = ChainLimit::get();17401741 1742 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1743 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1744 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1745 Error::<T>::CollectionLimitBoundsExceeded);17461747 1748 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1749 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17501751 ensure!(1752 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1753 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1754 Error::<T>::OwnerPermissionsCantBeReverted,1755 );17561757 target_collection.limits = new_limits;1758 Self::save_collection(target_collection);17591760 Ok(())1761 } 1762 }1763}17641765impl<T: Config> Module<T> {17661767 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1768 1769 Self::is_correct_transfer(target_collection, &recipient)?;17701771 1772 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1773 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1774 Error::<T>::NoPermission);17751776 if target_collection.access == AccessMode::WhiteList {1777 Self::check_white_list(target_collection, &sender)?;1778 Self::check_white_list(target_collection, &recipient)?;1779 }17801781 match target_collection.mode1782 {1783 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1784 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1785 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1786 _ => ()1787 };17881789 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17901791 Ok(())1792 }179317941795 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1796 let collection_id = collection.id;17971798 1799 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1800 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1801 1802 Ok(())1803 }18041805 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1806 let collection_id = collection.id;18071808 1809 let total_items: u32 = ItemListIndex::get(collection_id)1810 .checked_add(amount)1811 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1812 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1813 .checked_add(amount)1814 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1815 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1816 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18171818 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1819 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1820 Self::check_white_list(collection, owner)?;1821 Self::check_white_list(collection, sender)?;1822 }18231824 Ok(())1825 }18261827 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1828 match target_collection.mode1829 {1830 CollectionMode::NFT => {1831 if let CreateItemData::NFT(data) = data {1832 1833 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1834 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1835 } else {1836 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1837 }1838 },1839 CollectionMode::Fungible(_) => {1840 if let CreateItemData::Fungible(_) = data {1841 } else {1842 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1843 }1844 },1845 CollectionMode::ReFungible => {1846 if let CreateItemData::ReFungible(data) = data {18471848 1849 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1850 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18511852 1853 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1854 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1855 } else {1856 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1857 }1858 },1859 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1860 };18611862 Ok(())1863 }18641865 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1866 match data1867 {1868 CreateItemData::NFT(data) => {1869 let item = NftItemType {1870 owner: owner.clone(),1871 const_data: data.const_data,1872 variable_data: data.variable_data1873 };18741875 Self::add_nft_item(collection, item)?;1876 },1877 CreateItemData::Fungible(data) => {1878 Self::add_fungible_item(collection, &owner, data.value)?;1879 },1880 CreateItemData::ReFungible(data) => {1881 let mut owner_list = Vec::new();1882 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18831884 let item = ReFungibleItemType {1885 owner: owner_list,1886 const_data: data.const_data,1887 variable_data: data.variable_data1888 };18891890 Self::add_refungible_item(collection, item)?;1891 }1892 };18931894 Ok(())1895 }18961897 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1898 let collection_id = collection.id;18991900 1901 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19021903 1904 let item = FungibleItemType {1905 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1906 };1907 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19081909 1910 let new_balance = <Balance<T>>::get(collection_id, owner)1911 .checked_add(value)1912 .ok_or(Error::<T>::NumOverflow)?;1913 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19141915 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1916 Ok(())1917 }19181919 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1920 let collection_id = collection.id;19211922 let current_index = <ItemListIndex>::get(collection_id)1923 .checked_add(1)1924 .ok_or(Error::<T>::NumOverflow)?;1925 let itemcopy = item.clone();19261927 ensure!(1928 item.owner.len() == 1,1929 Error::<T>::BadCreateRefungibleCall,1930 );1931 let item_owner = item.owner.first().expect("only one owner is defined");19321933 let value = item_owner.fraction;1934 let owner = item_owner.owner.clone();19351936 Self::add_token_index(collection_id, current_index, &owner)?;19371938 <ItemListIndex>::insert(collection_id, current_index);1939 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19401941 1942 let new_balance = <Balance<T>>::get(collection_id, &owner)1943 .checked_add(value)1944 .ok_or(Error::<T>::NumOverflow)?;1945 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19461947 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1948 Ok(())1949 }19501951 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1952 let collection_id = collection.id;19531954 let current_index = <ItemListIndex>::get(collection_id)1955 .checked_add(1)1956 .ok_or(Error::<T>::NumOverflow)?;19571958 let item_owner = item.owner.clone();1959 Self::add_token_index(collection_id, current_index, &item.owner)?;19601961 <ItemListIndex>::insert(collection_id, current_index);1962 <NftItemList<T>>::insert(collection_id, current_index, item);19631964 1965 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1966 .checked_add(1)1967 .ok_or(Error::<T>::NumOverflow)?;1968 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19691970 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1971 Ok(())1972 }19731974 fn burn_refungible_item(1975 collection: &CollectionHandle<T>,1976 item_id: TokenId,1977 owner: &T::AccountId,1978 ) -> DispatchResult {1979 let collection_id = collection.id;19801981 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1982 .ok_or(Error::<T>::TokenNotFound)?;1983 let rft_balance = token1984 .owner1985 .iter()1986 .find(|&i| i.owner == *owner)1987 .ok_or(Error::<T>::TokenNotFound)?;1988 Self::remove_token_index(collection_id, item_id, owner)?;19891990 1991 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1992 .checked_sub(rft_balance.fraction)1993 .ok_or(Error::<T>::NumOverflow)?;1994 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19951996 1997 let index = token1998 .owner1999 .iter()2000 .position(|i| i.owner == *owner)2001 .expect("owned item is exists");2002 token.owner.remove(index);2003 let owner_count = token.owner.len();20042005 2006 if owner_count == 0 {2007 <ReFungibleItemList<T>>::remove(collection_id, item_id);2008 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2009 }2010 else {2011 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2012 }20132014 Ok(())2015 }20162017 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2018 let collection_id = collection.id;20192020 let item = <NftItemList<T>>::get(collection_id, item_id)2021 .ok_or(Error::<T>::TokenNotFound)?;2022 Self::remove_token_index(collection_id, item_id, &item.owner)?;20232024 2025 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2026 .checked_sub(1)2027 .ok_or(Error::<T>::NumOverflow)?;2028 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2029 <NftItemList<T>>::remove(collection_id, item_id);2030 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20312032 Ok(())2033 }20342035 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2036 let collection_id = collection.id;20372038 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2039 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20402041 2042 let new_balance = <Balance<T>>::get(collection_id, owner)2043 .checked_sub(value)2044 .ok_or(Error::<T>::NumOverflow)?;2045 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20462047 if balance.value - value > 0 {2048 balance.value -= value;2049 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2050 }2051 else {2052 <FungibleItemList<T>>::remove(collection_id, owner);2053 }20542055 Ok(())2056 }20572058 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2059 Ok(<CollectionById<T>>::get(collection_id)2060 .map(|collection| CollectionHandle {2061 id: collection_id,2062 collection2063 })2064 .ok_or(Error::<T>::CollectionNotFound)?)2065 }20662067 fn save_collection(collection: CollectionHandle<T>) {2068 <CollectionById<T>>::insert(collection.id, collection.collection);2069 }20702071 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2072 ensure!(2073 subject == target_collection.owner,2074 Error::<T>::NoPermission2075 );20762077 Ok(())2078 }20792080 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2081 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2082 }20832084 fn check_owner_or_admin_permissions(2085 collection: &CollectionHandle<T>,2086 subject: T::AccountId,2087 ) -> DispatchResult {2088 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20892090 Ok(())2091 }20922093 fn owned_amount(2094 subject: T::AccountId,2095 target_collection: &CollectionHandle<T>,2096 item_id: TokenId,2097 ) -> Option<u128> {2098 let collection_id = target_collection.id;20992100 match target_collection.mode {2101 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2102 .then(|| 1),2103 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2104 .value),2105 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2106 .owner2107 .iter()2108 .find(|i| i.owner == subject)2109 .map(|i| i.fraction),2110 CollectionMode::Invalid => None,2111 }2112 }21132114 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2115 match target_collection.mode {2116 CollectionMode::Fungible(_) => true,2117 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2118 }2119 }21202121 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2122 let collection_id = collection.id;21232124 let mes = Error::<T>::AddresNotInWhiteList;2125 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21262127 Ok(())2128 }21292130 2131 2132 fn token_exists(2133 target_collection: &CollectionHandle<T>,2134 item_id: TokenId,2135 ) -> DispatchResult {2136 let collection_id = target_collection.id;2137 let exists = match target_collection.mode2138 {2139 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2140 CollectionMode::Fungible(_) => true,2141 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2142 _ => false2143 };21442145 ensure!(exists == true, Error::<T>::TokenNotFound);2146 Ok(())2147 }21482149 fn transfer_fungible(2150 collection: &CollectionHandle<T>,2151 value: u128,2152 owner: &T::AccountId,2153 recipient: &T::AccountId,2154 ) -> DispatchResult {2155 let collection_id = collection.id;21562157 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2158 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21592160 2161 Self::add_fungible_item(collection, recipient, value)?;21622163 2164 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21652166 2167 if balance.value == value {2168 <FungibleItemList<T>>::remove(collection_id, owner);2169 }2170 else {2171 balance.value -= value;2172 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2173 }21742175 Ok(())2176 }21772178 fn transfer_refungible(2179 collection: &CollectionHandle<T>,2180 item_id: TokenId,2181 value: u128,2182 owner: T::AccountId,2183 new_owner: T::AccountId,2184 ) -> DispatchResult {2185 let collection_id = collection.id;2186 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2187 .ok_or(Error::<T>::TokenNotFound)?;21882189 let item = full_item2190 .owner2191 .iter()2192 .filter(|i| i.owner == owner)2193 .next()2194 .ok_or(Error::<T>::TokenNotFound)?;2195 let amount = item.fraction;21962197 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21982199 2200 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2201 .checked_sub(value)2202 .ok_or(Error::<T>::NumOverflow)?;2203 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22042205 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2206 .checked_add(value)2207 .ok_or(Error::<T>::NumOverflow)?;2208 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22092210 let old_owner = item.owner.clone();2211 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22122213 2214 if amount == value && !new_owner_has_account {2215 2216 2217 let mut new_full_item = full_item.clone();2218 new_full_item2219 .owner2220 .iter_mut()2221 .find(|i| i.owner == owner)2222 .expect("old owner does present in refungible")2223 .owner = new_owner.clone();2224 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22252226 2227 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2228 } else {2229 let mut new_full_item = full_item.clone();2230 new_full_item2231 .owner2232 .iter_mut()2233 .find(|i| i.owner == owner)2234 .expect("old owner does present in refungible")2235 .fraction -= value;22362237 2238 if new_owner_has_account {2239 2240 new_full_item2241 .owner2242 .iter_mut()2243 .find(|i| i.owner == new_owner)2244 .expect("new owner has account")2245 .fraction += value;2246 } else {2247 2248 new_full_item.owner.push(Ownership {2249 owner: new_owner.clone(),2250 fraction: value,2251 });2252 Self::add_token_index(collection_id, item_id, &new_owner)?;2253 }22542255 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2256 }22572258 Ok(())2259 }22602261 fn transfer_nft(2262 collection: &CollectionHandle<T>,2263 item_id: TokenId,2264 sender: T::AccountId,2265 new_owner: T::AccountId,2266 ) -> DispatchResult {2267 let collection_id = collection.id;2268 let mut item = <NftItemList<T>>::get(collection_id, item_id)2269 .ok_or(Error::<T>::TokenNotFound)?;22702271 ensure!(2272 sender == item.owner,2273 Error::<T>::MustBeTokenOwner2274 );22752276 2277 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2278 .checked_sub(1)2279 .ok_or(Error::<T>::NumOverflow)?;2280 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22812282 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2283 .checked_add(1)2284 .ok_or(Error::<T>::NumOverflow)?;2285 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22862287 2288 let old_owner = item.owner.clone();2289 item.owner = new_owner.clone();2290 <NftItemList<T>>::insert(collection_id, item_id, item);22912292 2293 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22942295 Ok(())2296 }2297 2298 fn set_re_fungible_variable_data(2299 collection: &CollectionHandle<T>,2300 item_id: TokenId,2301 data: Vec<u8>2302 ) -> DispatchResult {2303 let collection_id = collection.id;2304 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2305 .ok_or(Error::<T>::TokenNotFound)?;23062307 item.variable_data = data;23082309 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23102311 Ok(())2312 }23132314 fn set_nft_variable_data(2315 collection: &CollectionHandle<T>,2316 item_id: TokenId,2317 data: Vec<u8>2318 ) -> DispatchResult {2319 let collection_id = collection.id;2320 let mut item = <NftItemList<T>>::get(collection_id, item_id)2321 .ok_or(Error::<T>::TokenNotFound)?;2322 2323 item.variable_data = data;23242325 <NftItemList<T>>::insert(collection_id, item_id, item);2326 2327 Ok(())2328 }23292330 fn init_collection(item: &Collection<T>) {2331 2332 assert!(2333 item.decimal_points <= MAX_DECIMAL_POINTS,2334 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2335 );2336 assert!(2337 item.name.len() <= 64,2338 "Collection name can not be longer than 63 char"2339 );2340 assert!(2341 item.name.len() <= 256,2342 "Collection description can not be longer than 255 char"2343 );2344 assert!(2345 item.token_prefix.len() <= 16,2346 "Token prefix can not be longer than 15 char"2347 );23482349 2350 let next_id = CreatedCollectionCount::get()2351 .checked_add(1)2352 .unwrap();23532354 CreatedCollectionCount::put(next_id);2355 }23562357 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2358 let current_index = <ItemListIndex>::get(collection_id)2359 .checked_add(1)2360 .unwrap();23612362 let item_owner = item.owner.clone();2363 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23642365 <ItemListIndex>::insert(collection_id, current_index);23662367 2368 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2369 .checked_add(1)2370 .unwrap();2371 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2372 }23732374 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2375 let current_index = <ItemListIndex>::get(collection_id)2376 .checked_add(1)2377 .unwrap();23782379 Self::add_token_index(collection_id, current_index, owner).unwrap();23802381 <ItemListIndex>::insert(collection_id, current_index);23822383 2384 let new_balance = <Balance<T>>::get(collection_id, owner)2385 .checked_add(item.value)2386 .unwrap();2387 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2388 }23892390 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2391 let current_index = <ItemListIndex>::get(collection_id)2392 .checked_add(1)2393 .unwrap();23942395 let value = item.owner.first().unwrap().fraction;2396 let owner = item.owner.first().unwrap().owner.clone();23972398 Self::add_token_index(collection_id, current_index, &owner).unwrap();23992400 <ItemListIndex>::insert(collection_id, current_index);24012402 2403 let new_balance = <Balance<T>>::get(collection_id, &owner)2404 .checked_add(value)2405 .unwrap();2406 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2407 }24082409 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2410 2411 if <AccountItemCount<T>>::contains_key(owner) {24122413 2414 let count = <AccountItemCount<T>>::get(owner);2415 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24162417 <AccountItemCount<T>>::insert(owner.clone(), count2418 .checked_add(1)2419 .ok_or(Error::<T>::NumOverflow)?);2420 }2421 else {2422 <AccountItemCount<T>>::insert(owner.clone(), 1);2423 }24242425 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2426 if list_exists {2427 let mut list = <AddressTokens<T>>::get(collection_id, owner);2428 let item_contains = list.contains(&item_index.clone());24292430 if !item_contains {2431 list.push(item_index.clone());2432 }24332434 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2435 } else {2436 let mut itm = Vec::new();2437 itm.push(item_index.clone());2438 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2439 }24402441 Ok(())2442 }24432444 fn remove_token_index(2445 collection_id: CollectionId,2446 item_index: TokenId,2447 owner: &T::AccountId,2448 ) -> DispatchResult {24492450 2451 <AccountItemCount<T>>::insert(owner.clone(), 2452 <AccountItemCount<T>>::get(owner)2453 .checked_sub(1)2454 .ok_or(Error::<T>::NumOverflow)?);245524562457 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2458 if list_exists {2459 let mut list = <AddressTokens<T>>::get(collection_id, owner);2460 let item_contains = list.contains(&item_index.clone());24612462 if item_contains {2463 list.retain(|&item| item != item_index);2464 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2465 }2466 }24672468 Ok(())2469 }24702471 fn move_token_index(2472 collection_id: CollectionId,2473 item_index: TokenId,2474 old_owner: &T::AccountId,2475 new_owner: &T::AccountId,2476 ) -> DispatchResult {2477 Self::remove_token_index(collection_id, item_index, old_owner)?;2478 Self::add_token_index(collection_id, item_index, new_owner)?;24792480 Ok(())2481 }2482 2483 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2484 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24852486 Ok(())2487 }2488}2489249024912492249324942495pub type Multiplier = FixedU128;24962497type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2498249925002501#[derive(Encode, Decode, Clone, Eq, PartialEq)]2502pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25032504impl<T: Config + Send + Sync> sp_std::fmt::Debug 2505 for ChargeTransactionPayment<T>2506{2507 #[cfg(feature = "std")]2508 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2509 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2510 }2511 #[cfg(not(feature = "std"))]2512 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2513 Ok(())2514 }2515}25162517impl<T: Config> ChargeTransactionPayment<T>2518where2519 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2520 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2521 T::AccountId: AsRef<[u8]>,2522 T::AccountId: UncheckedFrom<T::Hash>,2523{2524 fn traditional_fee(2525 len: usize,2526 info: &DispatchInfoOf<T::Call>,2527 tip: BalanceOf<T>,2528 ) -> BalanceOf<T>2529 where2530 T::Call: Dispatchable<Info = DispatchInfo>,2531 {2532 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2533 }25342535 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2536 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2537 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2538 let len_saturation = max_block_length as u64 / (len as u64).max(1);2539 let coefficient: BalanceOf<T> = weight_saturation2540 .min(len_saturation)2541 .saturated_into::<BalanceOf<T>>();2542 final_fee2543 .saturating_mul(coefficient)2544 .saturated_into::<TransactionPriority>()2545 }25462547 fn withdraw_fee(2548 &self,2549 who: &T::AccountId,2550 call: &T::Call,2551 info: &DispatchInfoOf<T::Call>,2552 len: usize,2553 ) -> Result<2554 (2555 BalanceOf<T>,2556 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2557 ),2558 TransactionValidityError,2559 > {2560 let tip = self.0;25612562 let fee = Self::traditional_fee(len, info, tip);25632564 2565 if fee.is_zero() {2566 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2567 .map(|i| (fee, i));2568 }25692570 2571 2572 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2573 Some(Call::create_item(collection_id, _owner, _properties)) => {2574 let collection = <CollectionById<T>>::get(collection_id)?;25752576 2577 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25782579 let limit = collection.limits.sponsor_transfer_timeout;2580 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2581 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2582 let limit_time = last_tx_block + limit.into();2583 if block_number <= limit_time {2584 return None;2585 }2586 }2587 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25882589 2590 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2591 collection.sponsorship.sponsor()2592 .cloned()2593 } else {2594 None2595 }2596 }2597 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2598 let collection = <CollectionById<T>>::get(collection_id)?;2599 2600 let mut sponsor_transfer = false;2601 if collection.sponsorship.confirmed() {26022603 let collection_limits = collection.limits;2604 let collection_mode = collection.mode;2605 2606 2607 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2608 sponsor_transfer = match collection_mode {2609 CollectionMode::NFT => {2610 2611 2612 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2613 collection_limits.sponsor_transfer_timeout2614 } else {2615 ChainLimit::get().nft_sponsor_transfer_timeout2616 };2617 2618 let mut sponsored = true;2619 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2620 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2621 let limit_time = last_tx_block + limit.into();2622 if block_number <= limit_time {2623 sponsored = false;2624 }2625 }2626 if sponsored {2627 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2628 }26292630 sponsored2631 }2632 CollectionMode::Fungible(_) => {2633 2634 2635 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2636 collection_limits.sponsor_transfer_timeout2637 } else {2638 ChainLimit::get().fungible_sponsor_transfer_timeout2639 };2640 2641 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2642 let mut sponsored = true;2643 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2644 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2645 let limit_time = last_tx_block + limit.into();2646 if block_number <= limit_time {2647 sponsored = false;2648 }2649 }2650 if sponsored {2651 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2652 }26532654 sponsored2655 }2656 CollectionMode::ReFungible => {2657 2658 2659 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2660 collection_limits.sponsor_transfer_timeout2661 } else {2662 ChainLimit::get().refungible_sponsor_transfer_timeout2663 };2664 2665 let mut sponsored = true;2666 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2667 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2668 let limit_time = last_tx_block + limit.into();2669 if block_number <= limit_time {2670 sponsored = false;2671 }2672 }2673 if sponsored {2674 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2675 }26762677 sponsored2678 }2679 _ => {2680 false2681 },2682 };2683 }26842685 if !sponsor_transfer {2686 None2687 } else {2688 collection.sponsorship.sponsor()2689 .cloned()2690 }2691 }26922693 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2694 let mut sponsor_metadata_changes = false;26952696 let collection = <CollectionById<T>>::get(collection_id)?;26972698 if2699 collection.sponsorship.confirmed() &&2700 2701 2702 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2703 data.len() <= collection.limits.sponsored_data_size as usize2704 {2705 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2706 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27072708 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2709 .map(|last_block| block_number - last_block > rate_limit)2710 .unwrap_or(true) 2711 {2712 sponsor_metadata_changes = true;2713 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2714 }2715 }2716 }27172718 if !sponsor_metadata_changes {2719 None2720 } else {2721 collection.sponsorship.sponsor().cloned()2722 }2723 }27242725 _ => None,2726 })();27272728 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2729 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27302731 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27322733 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2734 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2735 2736 if !owned_contract && white_list_enabled {2737 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2738 return Err(InvalidTransaction::Call.into());2739 }2740 }2741 },2742 _ => {},2743 }27442745 2746 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27472748 2749 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27502751 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2752 &who,2753 code_hash,2754 salt,2755 );2756 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27572758 None2759 },27602761 2762 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27632764 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2765 &who,2766 &T::Hashing::hash(&_code),2767 _salt,2768 );27692770 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27712772 None2773 }27742775 2776 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27772778 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27792780 let mut sponsor_transfer = false;2781 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2782 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2783 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2784 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2785 let limit_time = last_tx_block + rate_limit;27862787 if block_number >= limit_time {2788 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2789 sponsor_transfer = true;2790 }2791 } else {2792 sponsor_transfer = false;2793 }2794 2795 if sponsor_transfer {2796 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2797 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2798 return Some(called_contract);2799 }2800 }2801 }28022803 None2804 },28052806 _ => None,2807 });28082809 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28102811 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2812 .map(|i| (fee, i))2813 }2814}281528162817impl<T: Config + Send + Sync> SignedExtension2818 for ChargeTransactionPayment<T>2819where2820 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2821 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2822 T::AccountId: AsRef<[u8]>,2823 T::AccountId: UncheckedFrom<T::Hash>,2824{2825 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2826 type AccountId = T::AccountId;2827 type Call = T::Call;2828 type AdditionalSigned = ();2829 type Pre = (2830 2831 BalanceOf<T>,2832 2833 Self::AccountId,2834 2835 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2836 );2837 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2838 Ok(())2839 }28402841 fn validate(2842 &self,2843 who: &Self::AccountId,2844 call: &Self::Call,2845 info: &DispatchInfoOf<Self::Call>,2846 len: usize,2847 ) -> TransactionValidity {2848 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2849 Ok(ValidTransaction {2850 priority: Self::get_priority(len, info, fee),2851 ..Default::default()2852 })2853 }28542855 fn pre_dispatch(2856 self,2857 who: &Self::AccountId,2858 call: &Self::Call,2859 info: &DispatchInfoOf<Self::Call>,2860 len: usize,2861 ) -> Result<Self::Pre, TransactionValidityError> {2862 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2863 Ok((self.0, who.clone(), imbalance))2864 }28652866 fn post_dispatch(2867 pre: Self::Pre,2868 info: &DispatchInfoOf<Self::Call>,2869 post_info: &PostDispatchInfoOf<Self::Call>,2870 len: usize,2871 _result: &DispatchResult,2872 ) -> Result<(), TransactionValidityError> {2873 let (tip, who, imbalance) = pre;2874 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2875 len as u32,2876 info,2877 post_info,2878 tip,2879 );2880 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2881 Ok(())2882 }2883}28842885