123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465666768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 134 Disabled,135 Unconfirmed(AccountId),136 137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, 174 pub description: Vec<u16>, 175 pub token_prefix: Vec<u8>, 176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::CrossAccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, 181 pub variable_on_chain_schema: Vec<u8>, 182 pub const_on_chain_schema: Vec<u8>, 183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191 type Target = Collection<T>;192193 fn deref(&self) -> &Self::Target {194 &self.collection195 }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199 fn deref_mut(&mut self) -> &mut Self::Target {200 &mut self.collection201 }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207 pub owner: AccountId,208 pub const_data: Vec<u8>,209 pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215 pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221 pub owner: Vec<Ownership<AccountId>>,222 pub const_data: Vec<u8>,223 pub variable_data: Vec<u8>,224}225226227228229230231232233234235236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240 pub account_token_ownership_limit: u32,241 pub sponsored_data_size: u32,242 243 244 245 pub sponsored_data_rate_limit: Option<BlockNumber>,246 pub token_limit: u32,247248 249 pub sponsor_transfer_timeout: u32,250 pub owner_can_transfer: bool,251 pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255 fn default() -> Self {256 Self { 257 account_token_ownership_limit: 10_000_000, 258 token_limit: u32::max_value(),259 sponsored_data_size: u32::MAX, 260 sponsored_data_rate_limit: None,261 sponsor_transfer_timeout: 14400,262 owner_can_transfer: true,263 owner_can_destroy: true264 }265 }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271 pub collection_numbers_limit: u32,272 pub account_token_ownership_limit: u32,273 pub collections_admins_limit: u64,274 pub custom_data_limit: u32,275276 277 pub nft_sponsor_transfer_timeout: u32,278 pub fungible_sponsor_transfer_timeout: u32,279 pub refungible_sponsor_transfer_timeout: u32,280281 282 pub offchain_schema_limit: u32,283 pub variable_on_chain_schema_limit: u32,284 pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288 fn create_collection() -> Weight;289 fn destroy_collection() -> Weight;290 fn add_to_white_list() -> Weight;291 fn remove_from_white_list() -> Weight;292 fn set_public_access_mode() -> Weight;293 fn set_mint_permission() -> Weight;294 fn change_collection_owner() -> Weight;295 fn add_collection_admin() -> Weight;296 fn remove_collection_admin() -> Weight;297 fn set_collection_sponsor() -> Weight;298 fn confirm_sponsorship() -> Weight;299 fn remove_collection_sponsor() -> Weight;300 fn create_item(s: usize) -> Weight;301 fn burn_item() -> Weight;302 fn transfer() -> Weight;303 fn approve() -> Weight;304 fn transfer_from() -> Weight;305 fn set_offchain_schema() -> Weight;306 fn set_const_on_chain_schema() -> Weight;307 fn set_variable_on_chain_schema() -> Weight;308 fn set_variable_meta_data() -> Weight;309 fn enable_contract_sponsoring() -> Weight;310 fn set_schema_version() -> Weight;311 fn set_chain_limits() -> Weight;312 fn set_contract_sponsoring_rate_limit() -> Weight;313 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314 fn toggle_contract_white_list() -> Weight;315 fn add_to_contract_white_list() -> Weight;316 fn remove_from_contract_white_list() -> Weight;317 fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323 pub const_data: Vec<u8>,324 pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330 pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336 pub const_data: Vec<u8>,337 pub variable_data: Vec<u8>,338 pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344 NFT(CreateNftData),345 Fungible(CreateFungibleData),346 ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350 pub fn len(&self) -> usize {351 let len = match self {352 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354 _ => 0355 };356 357 return len;358 }359}360361impl From<CreateNftData> for CreateItemData {362 fn from(item: CreateNftData) -> Self {363 CreateItemData::NFT(item)364 }365}366367impl From<CreateReFungibleData> for CreateItemData {368 fn from(item: CreateReFungibleData) -> Self {369 CreateItemData::ReFungible(item)370 }371}372373impl From<CreateFungibleData> for CreateItemData {374 fn from(item: CreateFungibleData) -> Self {375 CreateItemData::Fungible(item)376 }377}378379380decl_error! {381 382 pub enum Error for Module<T: Config> {383 384 TotalCollectionsLimitExceeded,385 386 CollectionDecimalPointLimitExceeded, 387 388 CollectionNameLimitExceeded, 389 390 CollectionDescriptionLimitExceeded, 391 392 CollectionTokenPrefixLimitExceeded,393 394 CollectionNotFound,395 396 TokenNotFound,397 398 AdminNotFound,399 400 NumOverflow, 401 402 AlreadyAdmin, 403 404 NoPermission,405 406 ConfirmUnsetSponsorFail,407 408 PublicMintingNotAllowed,409 410 MustBeTokenOwner,411 412 TokenValueTooLow,413 414 NftSizeLimitExceeded,415 416 ApproveNotFound,417 418 TokenValueNotEnough,419 420 ApproveRequired,421 422 AddresNotInWhiteList,423 424 CollectionAdminsLimitExceeded,425 426 AddressOwnershipLimitExceeded,427 428 EmptyArgument,429 430 TokenConstDataLimitExceeded,431 432 TokenVariableDataLimitExceeded,433 434 NotNftDataUsedToMintNftCollectionToken,435 436 NotFungibleDataUsedToMintFungibleCollectionToken,437 438 NotReFungibleDataUsedToMintReFungibleCollectionToken,439 440 UnexpectedCollectionType,441 442 CantStoreMetadataInFungibleTokens,443 444 CollectionTokenLimitExceeded,445 446 AccountTokenLimitExceeded,447 448 CollectionLimitBoundsExceeded,449 450 OwnerPermissionsCantBeReverted,451 452 SchemaDataLimitExceeded,453 454 WrongRefungiblePieces,455 456 BadCreateRefungibleCall,457 }458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463 464 type WeightInfo: WeightInfo;465466 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470 type CrossAccountId: CrossAccountId<Self::AccountId>;471 type Currency: Currency<Self::AccountId>;472 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473 type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479480481482483484485486487488489490491492493494495496497498499500501502503decl_storage! {504 trait Store for Module<T: Config> as Nft {505506 507 508 CreatedCollectionCount: u32;509 510 ChainVersion: u64;511 512 513 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514 515516 517 pub ChainLimit get(fn chain_limit) config(): ChainLimits;518 519520 521 522 523 DestroyedCollectionCount: u32;524 525 526 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527 528529 530 531 532 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533 534 535 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536 537 538 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539 540541 542 543 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545 546 547 548 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550 551 552 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553 554 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555 556 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557 558559 560 561 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562 563564 565 566 567 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568 569 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570 571 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572 573 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574 575576 577 578 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579 580 581 582 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583 584 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585 586 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587 588 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589 590 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591 592 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593 594 }595 add_extra_genesis {596 build(|config: &GenesisConfig<T>| {597 598 for (_num, _c) in &config.collection_id {599 <Module<T>>::init_collection(_c);600 }601602 for (_num, _c, _i) in &config.nft_item_id {603 <Module<T>>::init_nft_token(*_c, _i);604 }605606 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);608 }609610 for (_num, _c, _i) in &config.refungible_item_id {611 <Module<T>>::init_refungible_token(*_c, _i);612 }613 })614 }615}616617decl_event!(618 pub enum Event<T>619 where620 CrossAccountId = <T as Config>::CrossAccountId,621 {622 623 624 625 626 627 628 629 630 631 CollectionCreated(CollectionId, u8, CrossAccountId),632633 634 635 636 637 638 639 640 641 642 ItemCreated(CollectionId, TokenId, CrossAccountId),643644 645 646 647 648 649 650 651 ItemDestroyed(CollectionId, TokenId),652653 654 655 656 657 658 659 660 661 662 663 664 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666 667 668 669 670 671 672 673 674 675 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676 }677);678679decl_module! {680 pub struct Module<T: Config> for enum Call 681 where 682 origin: T::Origin683 {684 fn deposit_event() = default;685 type Error = Error<T>;686687 fn on_initialize(now: T::BlockNumber) -> Weight {688 0689 }690691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 #[weight = <T as Config>::WeightInfo::create_collection()]708 #[transactional]709 pub fn create_collection(origin,710 collection_name: Vec<u16>,711 collection_description: Vec<u16>,712 token_prefix: Vec<u8>,713 mode: CollectionMode) -> DispatchResult {714715 716 let who = ensure_signed(origin)?;717718 719 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721 &T::TreasuryAccountId::get(),722 T::CollectionCreationPrice::get(),723 ));724 <T as Config>::Currency::settle(725 &who,726 imbalance,727 WithdrawReasons::TRANSFER,728 ExistenceRequirement::KeepAlive,729 ).map_err(|_| Error::<T>::NoPermission)?;730731 let decimal_points = match mode {732 CollectionMode::Fungible(points) => points,733 _ => 0734 };735736 let chain_limit = ChainLimit::get();737738 let created_count = CreatedCollectionCount::get();739 let destroyed_count = DestroyedCollectionCount::get();740741 742 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744 745 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750 751 let next_id = created_count752 .checked_add(1)753 .ok_or(Error::<T>::NumOverflow)?;754755 CreatedCollectionCount::put(next_id);756757 let limits = CollectionLimits {758 sponsored_data_size: chain_limit.custom_data_limit,759 ..Default::default()760 };761762 763 let new_collection = Collection {764 owner: who.clone(),765 name: collection_name,766 mode: mode.clone(),767 mint_mode: false,768 access: AccessMode::Normal,769 description: collection_description,770 decimal_points: decimal_points,771 token_prefix: token_prefix,772 offchain_schema: Vec::new(),773 schema_version: SchemaVersion::ImageURL,774 sponsorship: SponsorshipState::Disabled,775 variable_on_chain_schema: Vec::new(),776 const_on_chain_schema: Vec::new(),777 limits,778 };779780 781 <CollectionById<T>>::insert(next_id, new_collection);782783 784 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));785786 Ok(())787 }788789 790 791 792 793 794 795 796 797 798 #[weight = <T as Config>::WeightInfo::destroy_collection()]799 #[transactional]800 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802 let sender = ensure_signed(origin)?;803 let collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&collection, sender)?;805 if !collection.limits.owner_can_destroy {806 fail!(Error::<T>::NoPermission);807 }808809 <AddressTokens<T>>::remove_prefix(collection_id);810 <Allowances<T>>::remove_prefix(collection_id);811 <Balance<T>>::remove_prefix(collection_id);812 <ItemListIndex>::remove(collection_id);813 <AdminList<T>>::remove(collection_id);814 <CollectionById<T>>::remove(collection_id);815 <WhiteList<T>>::remove_prefix(collection_id);816817 <NftItemList<T>>::remove_prefix(collection_id);818 <FungibleItemList<T>>::remove_prefix(collection_id);819 <ReFungibleItemList<T>>::remove_prefix(collection_id);820821 <NftTransferBasket<T>>::remove_prefix(collection_id);822 <FungibleTransferBasket<T>>::remove_prefix(collection_id);823 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827 DestroyedCollectionCount::put(DestroyedCollectionCount::get()828 .checked_add(1)829 .ok_or(Error::<T>::NumOverflow)?);830831 Ok(())832 }833834 835 836 837 838 839 840 841 842 843 844 845 846 #[weight = <T as Config>::WeightInfo::add_to_white_list()]847 #[transactional]848 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{849850 let sender = ensure_signed(origin)?;851 let collection = Self::get_collection(collection_id)?;852 Self::check_owner_or_admin_permissions(&collection, sender)?;853854 <WhiteList<T>>::insert(collection_id, address, true);855 856 Ok(())857 }858859 860 861 862 863 864 865 866 867 868 869 870 871 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872 #[transactional]873 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{874875 let sender = ensure_signed(origin)?;876 let collection = Self::get_collection(collection_id)?;877 Self::check_owner_or_admin_permissions(&collection, sender)?;878879 <WhiteList<T>>::remove(collection_id, address);880881 Ok(())882 }883884 885 886 887 888 889 890 891 892 893 894 895 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896 #[transactional]897 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898 {899 let sender = ensure_signed(origin)?;900901 let mut target_collection = Self::get_collection(collection_id)?;902 Self::check_owner_permissions(&target_collection, sender)?;903 target_collection.access = mode;904 Self::save_collection(target_collection);905906 Ok(())907 }908909 910 911 912 913 914 915 916 917 918 919 920 921 922 #[weight = <T as Config>::WeightInfo::set_mint_permission()]923 #[transactional]924 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925 {926 let sender = ensure_signed(origin)?;927928 let mut target_collection = Self::get_collection(collection_id)?;929 Self::check_owner_permissions(&target_collection, sender)?;930 target_collection.mint_mode = mint_permission;931 Self::save_collection(target_collection);932933 Ok(())934 }935936 937 938 939 940 941 942 943 944 945 946 947 #[weight = <T as Config>::WeightInfo::change_collection_owner()]948 #[transactional]949 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {950951 let sender = ensure_signed(origin)?;952 let mut target_collection = Self::get_collection(collection_id)?;953 Self::check_owner_permissions(&target_collection, sender)?;954 target_collection.owner = new_owner;955 Self::save_collection(target_collection);956957 Ok(())958 }959960 961 962 963 964 965 966 967 968 969 970 971 972 973 #[weight = <T as Config>::WeightInfo::add_collection_admin()]974 #[transactional]975 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {976977 let sender = ensure_signed(origin)?;978 let collection = Self::get_collection(collection_id)?;979 Self::check_owner_or_admin_permissions(&collection, sender)?;980 let mut admin_arr = <AdminList<T>>::get(collection_id);981982 match admin_arr.binary_search(&new_admin_id) {983 Ok(_) => {},984 Err(idx) => {985 let limits = ChainLimit::get();986 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);987 admin_arr.insert(idx, new_admin_id);988 <AdminList<T>>::insert(collection_id, admin_arr);989 }990 }991 Ok(())992 }993994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1007 #[transactional]1008 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10091010 let sender = ensure_signed(origin)?;1011 let collection = Self::get_collection(collection_id)?;1012 Self::check_owner_or_admin_permissions(&collection, sender)?;1013 let mut admin_arr = <AdminList<T>>::get(collection_id);10141015 match admin_arr.binary_search(&account_id) {1016 Ok(idx) => {1017 admin_arr.remove(idx);1018 <AdminList<T>>::insert(collection_id, admin_arr);1019 },1020 Err(_) => {}1021 }1022 Ok(())1023 }10241025 1026 1027 1028 1029 1030 1031 1032 1033 1034 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1035 #[transactional]1036 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10371038 let sender = ensure_signed(origin)?;1039 let mut target_collection = Self::get_collection(collection_id)?;1040 Self::check_owner_permissions(&target_collection, sender)?;10411042 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1043 Self::save_collection(target_collection);10441045 Ok(())1046 }10471048 1049 1050 1051 1052 1053 1054 1055 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1056 #[transactional]1057 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10581059 let sender = ensure_signed(origin)?;10601061 let mut target_collection = Self::get_collection(collection_id)?;1062 ensure!(1063 target_collection.sponsorship.pending_sponsor() == Some(&sender),1064 Error::<T>::ConfirmUnsetSponsorFail1065 );10661067 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1068 Self::save_collection(target_collection);10691070 Ok(())1071 }10721073 1074 1075 1076 1077 1078 1079 1080 1081 1082 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1083 #[transactional]1084 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10851086 let sender = ensure_signed(origin)?;10871088 let mut target_collection = Self::get_collection(collection_id)?;1089 Self::check_owner_permissions(&target_collection, sender)?;10901091 target_collection.sponsorship = SponsorshipState::Disabled;1092 Self::save_collection(target_collection);10931094 Ok(())1095 }10961097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 11201121 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1122 #[transactional]1123 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11241125 let sender = ensure_signed(origin)?;11261127 let target_collection = Self::get_collection(collection_id)?;11281129 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1130 Self::validate_create_item_args(&target_collection, &data)?;1131 Self::create_item_no_validation(&target_collection, owner, data)?;11321133 Ok(())1134 }11351136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1155 .map(|data| { data.len() })1156 .sum())]1157 #[transactional]1158 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11591160 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1161 let sender = ensure_signed(origin)?;11621163 let target_collection = Self::get_collection(collection_id)?;11641165 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11661167 for data in &items_data {1168 Self::validate_create_item_args(&target_collection, data)?;1169 }1170 for data in &items_data {1171 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1172 }11731174 Ok(())1175 }11761177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 #[weight = <T as Config>::WeightInfo::burn_item()]1191 #[transactional]1192 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11931194 let sender = ensure_signed(origin)?;11951196 1197 let target_collection = Self::get_collection(collection_id)?;1198 ensure!(1199 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1200 (1201 target_collection.limits.owner_can_transfer &&1202 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1203 ),1204 Error::<T>::NoPermission1205 );12061207 if target_collection.access == AccessMode::WhiteList {1208 Self::check_white_list(&target_collection, &sender)?;1209 }12101211 match target_collection.mode1212 {1213 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1214 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1215 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1216 _ => ()1217 };12181219 1220 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12211222 Ok(())1223 }12241225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 #[weight = <T as Config>::WeightInfo::transfer()]1249 #[transactional]1250 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1251 let sender = ensure_signed(origin)?;1252 let collection = Self::get_collection(collection_id)?;12531254 Self::transfer_internal(sender, recipient, &collection, item_id, value)1255 }12561257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 #[weight = <T as Config>::WeightInfo::approve()]1273 #[transactional]1274 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12751276 let sender = ensure_signed(origin)?;1277 let target_collection = Self::get_collection(collection_id)?;12781279 Self::token_exists(&target_collection, item_id)?;12801281 1282 let bypasses_limits = target_collection.limits.owner_can_transfer &&1283 Self::is_owner_or_admin_permissions(1284 &target_collection,1285 sender.clone(),1286 );12871288 let allowance_limit = if bypasses_limits {1289 None1290 } else if let Some(amount) = Self::owned_amount(1291 sender.clone(),1292 &target_collection,1293 item_id,1294 ) {1295 Some(amount)1296 } else {1297 fail!(Error::<T>::NoPermission);1298 };12991300 if target_collection.access == AccessMode::WhiteList {1301 Self::check_white_list(&target_collection, &sender)?;1302 Self::check_white_list(&target_collection, &spender)?;1303 }13041305 let allowance: u128 = amount1306 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1307 .ok_or(Error::<T>::NumOverflow)?;1308 if let Some(limit) = allowance_limit {1309 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1310 }1311 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13121313 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1314 Ok(())1315 }1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 #[weight = <T as Config>::WeightInfo::transfer_from()]1337 #[transactional]1338 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13391340 let sender = ensure_signed(origin)?;1341 let target_collection = Self::get_collection(collection_id)?;13421343 1344 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13451346 1347 Self::is_correct_transfer(&target_collection, &recipient)?;13481349 1350 ensure!(1351 approval >= value || 1352 (1353 target_collection.limits.owner_can_transfer &&1354 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1355 ),1356 Error::<T>::NoPermission1357 );13581359 if target_collection.access == AccessMode::WhiteList {1360 Self::check_white_list(&target_collection, &sender)?;1361 Self::check_white_list(&target_collection, &recipient)?;1362 }13631364 1365 if approval.saturating_sub(value) > 0 {1366 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1367 }1368 else {1369 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1370 }13711372 match target_collection.mode1373 {1374 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1375 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1376 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1377 _ => ()1378 };13791380 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1381 Ok(())1382 }13831384 1385 13861387 1388 1389 1390 13911392 13931394 13951396 1397 13981399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1412 #[transactional]1413 pub fn set_variable_meta_data (1414 origin,1415 collection_id: CollectionId,1416 item_id: TokenId,1417 data: Vec<u8>1418 ) -> DispatchResult {1419 let sender = ensure_signed(origin)?;1420 1421 let target_collection = Self::get_collection(collection_id)?;1422 Self::token_exists(&target_collection, item_id)?;14231424 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14251426 1427 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1428 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1429 Error::<T>::NoPermission);14301431 match target_collection.mode1432 {1433 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1434 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1435 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1436 _ => fail!(Error::<T>::UnexpectedCollectionType)1437 };14381439 Ok(())1440 }1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 #[weight = <T as Config>::WeightInfo::set_schema_version()]1457 #[transactional]1458 pub fn set_schema_version(1459 origin,1460 collection_id: CollectionId,1461 version: SchemaVersion1462 ) -> DispatchResult {1463 let sender = ensure_signed(origin)?;1464 let mut target_collection = Self::get_collection(collection_id)?;1465 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1466 target_collection.schema_version = version;1467 Self::save_collection(target_collection);14681469 Ok(())1470 }14711472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1485 #[transactional]1486 pub fn set_offchain_schema(1487 origin,1488 collection_id: CollectionId,1489 schema: Vec<u8>1490 ) -> DispatchResult {1491 let sender = ensure_signed(origin)?;1492 let mut target_collection = Self::get_collection(collection_id)?;1493 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14941495 1496 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14971498 target_collection.offchain_schema = schema;1499 Self::save_collection(target_collection);15001501 Ok(())1502 }15031504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1517 #[transactional]1518 pub fn set_const_on_chain_schema (1519 origin,1520 collection_id: CollectionId,1521 schema: Vec<u8>1522 ) -> DispatchResult {1523 let sender = ensure_signed(origin)?;1524 let mut target_collection = Self::get_collection(collection_id)?;1525 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15261527 1528 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15291530 target_collection.const_on_chain_schema = schema;1531 Self::save_collection(target_collection);15321533 Ok(())1534 }15351536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1549 #[transactional]1550 pub fn set_variable_on_chain_schema (1551 origin,1552 collection_id: CollectionId,1553 schema: Vec<u8>1554 ) -> DispatchResult {1555 let sender = ensure_signed(origin)?;1556 let mut target_collection = Self::get_collection(collection_id)?;1557 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15581559 1560 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15611562 target_collection.variable_on_chain_schema = schema;1563 Self::save_collection(target_collection);15641565 Ok(())1566 }15671568 1569 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1570 #[transactional]1571 pub fn set_chain_limits(1572 origin,1573 limits: ChainLimits1574 ) -> DispatchResult {15751576 #[cfg(not(feature = "runtime-benchmarks"))]1577 ensure_root(origin)?;15781579 <ChainLimit>::put(limits);1580 Ok(())1581 }15821583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1595 #[transactional]1596 pub fn enable_contract_sponsoring(1597 origin,1598 contract_address: T::AccountId,1599 enable: bool1600 ) -> DispatchResult {16011602 let sender = ensure_signed(origin)?;16031604 #[cfg(feature = "runtime-benchmarks")]1605 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16061607 Self::ensure_contract_owned(sender, &contract_address)?;16081609 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1610 Ok(())1611 }16121613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1631 #[transactional]1632 pub fn set_contract_sponsoring_rate_limit(1633 origin,1634 contract_address: T::AccountId,1635 rate_limit: T::BlockNumber1636 ) -> DispatchResult {1637 let sender = ensure_signed(origin)?;16381639 #[cfg(feature = "runtime-benchmarks")]1640 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16411642 Self::ensure_contract_owned(sender, &contract_address)?;1643 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1644 Ok(())1645 }16461647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1659 #[transactional]1660 pub fn toggle_contract_white_list(1661 origin,1662 contract_address: T::AccountId,1663 enable: bool1664 ) -> DispatchResult {1665 let sender = ensure_signed(origin)?;16661667 #[cfg(feature = "runtime-benchmarks")]1668 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16691670 Self::ensure_contract_owned(sender, &contract_address)?;1671 if enable {1672 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1673 } else {1674 <ContractWhiteListEnabled<T>>::remove(contract_address);1675 }1676 Ok(())1677 }1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1691 #[transactional]1692 pub fn add_to_contract_white_list(1693 origin,1694 contract_address: T::AccountId,1695 account_address: T::AccountId1696 ) -> DispatchResult {1697 let sender = ensure_signed(origin)?;16981699 #[cfg(feature = "runtime-benchmarks")]1700 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1701 1702 Self::ensure_contract_owned(sender, &contract_address)?; 1703 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1704 Ok(())1705 }17061707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1719 #[transactional]1720 pub fn remove_from_contract_white_list(1721 origin,1722 contract_address: T::AccountId,1723 account_address: T::AccountId1724 ) -> DispatchResult {1725 let sender = ensure_signed(origin)?;17261727 #[cfg(feature = "runtime-benchmarks")]1728 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17291730 Self::ensure_contract_owned(sender, &contract_address)?;1731 <ContractWhiteList<T>>::remove(contract_address, account_address);1732 Ok(())1733 }17341735 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1736 #[transactional]1737 pub fn set_collection_limits(1738 origin,1739 collection_id: u32,1740 new_limits: CollectionLimits<T::BlockNumber>,1741 ) -> DispatchResult {1742 let sender = ensure_signed(origin)?;1743 let mut target_collection = Self::get_collection(collection_id)?;1744 Self::check_owner_permissions(&target_collection, sender.clone())?;1745 let old_limits = &target_collection.limits;1746 let chain_limits = ChainLimit::get();17471748 1749 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1750 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1751 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1752 Error::<T>::CollectionLimitBoundsExceeded);17531754 1755 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1756 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17571758 ensure!(1759 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1760 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1761 Error::<T>::OwnerPermissionsCantBeReverted,1762 );17631764 target_collection.limits = new_limits;1765 Self::save_collection(target_collection);17661767 Ok(())1768 } 1769 }1770}17711772impl<T: Config> Module<T> {17731774 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1775 1776 Self::is_correct_transfer(target_collection, &recipient)?;17771778 1779 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1780 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1781 Error::<T>::NoPermission);17821783 if target_collection.access == AccessMode::WhiteList {1784 Self::check_white_list(target_collection, &sender)?;1785 Self::check_white_list(target_collection, &recipient)?;1786 }17871788 match target_collection.mode1789 {1790 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1791 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1792 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1793 _ => ()1794 };17951796 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17971798 Ok(())1799 }180018011802 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1803 let collection_id = collection.id;18041805 1806 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1807 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1808 1809 Ok(())1810 }18111812 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1813 let collection_id = collection.id;18141815 1816 let total_items: u32 = ItemListIndex::get(collection_id)1817 .checked_add(amount)1818 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1819 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1820 .checked_add(amount)1821 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1822 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1823 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18241825 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1826 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1827 Self::check_white_list(collection, owner)?;1828 Self::check_white_list(collection, sender)?;1829 }18301831 Ok(())1832 }18331834 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1835 match target_collection.mode1836 {1837 CollectionMode::NFT => {1838 if let CreateItemData::NFT(data) = data {1839 1840 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1841 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1842 } else {1843 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1844 }1845 },1846 CollectionMode::Fungible(_) => {1847 if let CreateItemData::Fungible(_) = data {1848 } else {1849 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1850 }1851 },1852 CollectionMode::ReFungible => {1853 if let CreateItemData::ReFungible(data) = data {18541855 1856 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1857 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18581859 1860 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1861 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1862 } else {1863 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1864 }1865 },1866 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1867 };18681869 Ok(())1870 }18711872 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1873 match data1874 {1875 CreateItemData::NFT(data) => {1876 let item = NftItemType {1877 owner: owner.clone(),1878 const_data: data.const_data,1879 variable_data: data.variable_data1880 };18811882 Self::add_nft_item(collection, item)?;1883 },1884 CreateItemData::Fungible(data) => {1885 Self::add_fungible_item(collection, &owner, data.value)?;1886 },1887 CreateItemData::ReFungible(data) => {1888 let mut owner_list = Vec::new();1889 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18901891 let item = ReFungibleItemType {1892 owner: owner_list,1893 const_data: data.const_data,1894 variable_data: data.variable_data1895 };18961897 Self::add_refungible_item(collection, item)?;1898 }1899 };19001901 Ok(())1902 }19031904 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1905 let collection_id = collection.id;19061907 1908 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19091910 1911 let item = FungibleItemType {1912 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1913 };1914 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19151916 1917 let new_balance = <Balance<T>>::get(collection_id, owner)1918 .checked_add(value)1919 .ok_or(Error::<T>::NumOverflow)?;1920 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19211922 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1923 Ok(())1924 }19251926 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1927 let collection_id = collection.id;19281929 let current_index = <ItemListIndex>::get(collection_id)1930 .checked_add(1)1931 .ok_or(Error::<T>::NumOverflow)?;1932 let itemcopy = item.clone();19331934 ensure!(1935 item.owner.len() == 1,1936 Error::<T>::BadCreateRefungibleCall,1937 );1938 let item_owner = item.owner.first().expect("only one owner is defined");19391940 let value = item_owner.fraction;1941 let owner = item_owner.owner.clone();19421943 Self::add_token_index(collection_id, current_index, &owner)?;19441945 <ItemListIndex>::insert(collection_id, current_index);1946 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19471948 1949 let new_balance = <Balance<T>>::get(collection_id, &owner)1950 .checked_add(value)1951 .ok_or(Error::<T>::NumOverflow)?;1952 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19531954 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1955 Ok(())1956 }19571958 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1959 let collection_id = collection.id;19601961 let current_index = <ItemListIndex>::get(collection_id)1962 .checked_add(1)1963 .ok_or(Error::<T>::NumOverflow)?;19641965 let item_owner = item.owner.clone();1966 Self::add_token_index(collection_id, current_index, &item.owner)?;19671968 <ItemListIndex>::insert(collection_id, current_index);1969 <NftItemList<T>>::insert(collection_id, current_index, item);19701971 1972 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1973 .checked_add(1)1974 .ok_or(Error::<T>::NumOverflow)?;1975 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19761977 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1978 Ok(())1979 }19801981 fn burn_refungible_item(1982 collection: &CollectionHandle<T>,1983 item_id: TokenId,1984 owner: &T::AccountId,1985 ) -> DispatchResult {1986 let collection_id = collection.id;19871988 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1989 .ok_or(Error::<T>::TokenNotFound)?;1990 let rft_balance = token1991 .owner1992 .iter()1993 .find(|&i| i.owner == *owner)1994 .ok_or(Error::<T>::TokenNotFound)?;1995 Self::remove_token_index(collection_id, item_id, owner)?;19961997 1998 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1999 .checked_sub(rft_balance.fraction)2000 .ok_or(Error::<T>::NumOverflow)?;2001 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20022003 2004 let index = token2005 .owner2006 .iter()2007 .position(|i| i.owner == *owner)2008 .expect("owned item is exists");2009 token.owner.remove(index);2010 let owner_count = token.owner.len();20112012 2013 if owner_count == 0 {2014 <ReFungibleItemList<T>>::remove(collection_id, item_id);2015 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2016 }2017 else {2018 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2019 }20202021 Ok(())2022 }20232024 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2025 let collection_id = collection.id;20262027 let item = <NftItemList<T>>::get(collection_id, item_id)2028 .ok_or(Error::<T>::TokenNotFound)?;2029 Self::remove_token_index(collection_id, item_id, &item.owner)?;20302031 2032 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2033 .checked_sub(1)2034 .ok_or(Error::<T>::NumOverflow)?;2035 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2036 <NftItemList<T>>::remove(collection_id, item_id);2037 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20382039 Ok(())2040 }20412042 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2043 let collection_id = collection.id;20442045 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2046 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20472048 2049 let new_balance = <Balance<T>>::get(collection_id, owner)2050 .checked_sub(value)2051 .ok_or(Error::<T>::NumOverflow)?;2052 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20532054 if balance.value - value > 0 {2055 balance.value -= value;2056 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2057 }2058 else {2059 <FungibleItemList<T>>::remove(collection_id, owner);2060 }20612062 Ok(())2063 }20642065 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2066 Ok(<CollectionById<T>>::get(collection_id)2067 .map(|collection| CollectionHandle {2068 id: collection_id,2069 collection2070 })2071 .ok_or(Error::<T>::CollectionNotFound)?)2072 }20732074 fn save_collection(collection: CollectionHandle<T>) {2075 <CollectionById<T>>::insert(collection.id, collection.collection);2076 }20772078 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2079 ensure!(2080 subject == target_collection.owner,2081 Error::<T>::NoPermission2082 );20832084 Ok(())2085 }20862087 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2088 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2089 }20902091 fn check_owner_or_admin_permissions(2092 collection: &CollectionHandle<T>,2093 subject: T::AccountId,2094 ) -> DispatchResult {2095 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20962097 Ok(())2098 }20992100 fn owned_amount(2101 subject: T::AccountId,2102 target_collection: &CollectionHandle<T>,2103 item_id: TokenId,2104 ) -> Option<u128> {2105 let collection_id = target_collection.id;21062107 match target_collection.mode {2108 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2109 .then(|| 1),2110 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2111 .value),2112 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2113 .owner2114 .iter()2115 .find(|i| i.owner == subject)2116 .map(|i| i.fraction),2117 CollectionMode::Invalid => None,2118 }2119 }21202121 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2122 match target_collection.mode {2123 CollectionMode::Fungible(_) => true,2124 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2125 }2126 }21272128 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2129 let collection_id = collection.id;21302131 let mes = Error::<T>::AddresNotInWhiteList;2132 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21332134 Ok(())2135 }21362137 2138 2139 fn token_exists(2140 target_collection: &CollectionHandle<T>,2141 item_id: TokenId,2142 ) -> DispatchResult {2143 let collection_id = target_collection.id;2144 let exists = match target_collection.mode2145 {2146 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2147 CollectionMode::Fungible(_) => true,2148 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2149 _ => false2150 };21512152 ensure!(exists == true, Error::<T>::TokenNotFound);2153 Ok(())2154 }21552156 fn transfer_fungible(2157 collection: &CollectionHandle<T>,2158 value: u128,2159 owner: &T::AccountId,2160 recipient: &T::AccountId,2161 ) -> DispatchResult {2162 let collection_id = collection.id;21632164 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2165 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21662167 2168 Self::add_fungible_item(collection, recipient, value)?;21692170 2171 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21722173 2174 if balance.value == value {2175 <FungibleItemList<T>>::remove(collection_id, owner);2176 }2177 else {2178 balance.value -= value;2179 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2180 }21812182 Ok(())2183 }21842185 fn transfer_refungible(2186 collection: &CollectionHandle<T>,2187 item_id: TokenId,2188 value: u128,2189 owner: T::AccountId,2190 new_owner: T::AccountId,2191 ) -> DispatchResult {2192 let collection_id = collection.id;2193 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2194 .ok_or(Error::<T>::TokenNotFound)?;21952196 let item = full_item2197 .owner2198 .iter()2199 .filter(|i| i.owner == owner)2200 .next()2201 .ok_or(Error::<T>::TokenNotFound)?;2202 let amount = item.fraction;22032204 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22052206 2207 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2208 .checked_sub(value)2209 .ok_or(Error::<T>::NumOverflow)?;2210 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22112212 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2213 .checked_add(value)2214 .ok_or(Error::<T>::NumOverflow)?;2215 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22162217 let old_owner = item.owner.clone();2218 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22192220 2221 if amount == value && !new_owner_has_account {2222 2223 2224 let mut new_full_item = full_item.clone();2225 new_full_item2226 .owner2227 .iter_mut()2228 .find(|i| i.owner == owner)2229 .expect("old owner does present in refungible")2230 .owner = new_owner.clone();2231 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22322233 2234 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2235 } else {2236 let mut new_full_item = full_item.clone();2237 new_full_item2238 .owner2239 .iter_mut()2240 .find(|i| i.owner == owner)2241 .expect("old owner does present in refungible")2242 .fraction -= value;22432244 2245 if new_owner_has_account {2246 2247 new_full_item2248 .owner2249 .iter_mut()2250 .find(|i| i.owner == new_owner)2251 .expect("new owner has account")2252 .fraction += value;2253 } else {2254 2255 new_full_item.owner.push(Ownership {2256 owner: new_owner.clone(),2257 fraction: value,2258 });2259 Self::add_token_index(collection_id, item_id, &new_owner)?;2260 }22612262 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2263 }22642265 Ok(())2266 }22672268 fn transfer_nft(2269 collection: &CollectionHandle<T>,2270 item_id: TokenId,2271 sender: T::AccountId,2272 new_owner: T::AccountId,2273 ) -> DispatchResult {2274 let collection_id = collection.id;2275 let mut item = <NftItemList<T>>::get(collection_id, item_id)2276 .ok_or(Error::<T>::TokenNotFound)?;22772278 ensure!(2279 sender == item.owner,2280 Error::<T>::MustBeTokenOwner2281 );22822283 2284 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2285 .checked_sub(1)2286 .ok_or(Error::<T>::NumOverflow)?;2287 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22882289 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2290 .checked_add(1)2291 .ok_or(Error::<T>::NumOverflow)?;2292 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22932294 2295 let old_owner = item.owner.clone();2296 item.owner = new_owner.clone();2297 <NftItemList<T>>::insert(collection_id, item_id, item);22982299 2300 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23012302 Ok(())2303 }2304 2305 fn set_re_fungible_variable_data(2306 collection: &CollectionHandle<T>,2307 item_id: TokenId,2308 data: Vec<u8>2309 ) -> DispatchResult {2310 let collection_id = collection.id;2311 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2312 .ok_or(Error::<T>::TokenNotFound)?;23132314 item.variable_data = data;23152316 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23172318 Ok(())2319 }23202321 fn set_nft_variable_data(2322 collection: &CollectionHandle<T>,2323 item_id: TokenId,2324 data: Vec<u8>2325 ) -> DispatchResult {2326 let collection_id = collection.id;2327 let mut item = <NftItemList<T>>::get(collection_id, item_id)2328 .ok_or(Error::<T>::TokenNotFound)?;2329 2330 item.variable_data = data;23312332 <NftItemList<T>>::insert(collection_id, item_id, item);2333 2334 Ok(())2335 }23362337 fn init_collection(item: &Collection<T>) {2338 2339 assert!(2340 item.decimal_points <= MAX_DECIMAL_POINTS,2341 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2342 );2343 assert!(2344 item.name.len() <= 64,2345 "Collection name can not be longer than 63 char"2346 );2347 assert!(2348 item.name.len() <= 256,2349 "Collection description can not be longer than 255 char"2350 );2351 assert!(2352 item.token_prefix.len() <= 16,2353 "Token prefix can not be longer than 15 char"2354 );23552356 2357 let next_id = CreatedCollectionCount::get()2358 .checked_add(1)2359 .unwrap();23602361 CreatedCollectionCount::put(next_id);2362 }23632364 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2365 let current_index = <ItemListIndex>::get(collection_id)2366 .checked_add(1)2367 .unwrap();23682369 let item_owner = item.owner.clone();2370 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23712372 <ItemListIndex>::insert(collection_id, current_index);23732374 2375 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2376 .checked_add(1)2377 .unwrap();2378 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2379 }23802381 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2382 let current_index = <ItemListIndex>::get(collection_id)2383 .checked_add(1)2384 .unwrap();23852386 Self::add_token_index(collection_id, current_index, owner).unwrap();23872388 <ItemListIndex>::insert(collection_id, current_index);23892390 2391 let new_balance = <Balance<T>>::get(collection_id, owner)2392 .checked_add(item.value)2393 .unwrap();2394 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2395 }23962397 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2398 let current_index = <ItemListIndex>::get(collection_id)2399 .checked_add(1)2400 .unwrap();24012402 let value = item.owner.first().unwrap().fraction;2403 let owner = item.owner.first().unwrap().owner.clone();24042405 Self::add_token_index(collection_id, current_index, &owner).unwrap();24062407 <ItemListIndex>::insert(collection_id, current_index);24082409 2410 let new_balance = <Balance<T>>::get(collection_id, &owner)2411 .checked_add(value)2412 .unwrap();2413 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2414 }24152416 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2417 2418 if <AccountItemCount<T>>::contains_key(owner) {24192420 2421 let count = <AccountItemCount<T>>::get(owner);2422 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24232424 <AccountItemCount<T>>::insert(owner.clone(), count2425 .checked_add(1)2426 .ok_or(Error::<T>::NumOverflow)?);2427 }2428 else {2429 <AccountItemCount<T>>::insert(owner.clone(), 1);2430 }24312432 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2433 if list_exists {2434 let mut list = <AddressTokens<T>>::get(collection_id, owner);2435 let item_contains = list.contains(&item_index.clone());24362437 if !item_contains {2438 list.push(item_index.clone());2439 }24402441 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2442 } else {2443 let mut itm = Vec::new();2444 itm.push(item_index.clone());2445 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2446 }24472448 Ok(())2449 }24502451 fn remove_token_index(2452 collection_id: CollectionId,2453 item_index: TokenId,2454 owner: &T::AccountId,2455 ) -> DispatchResult {24562457 2458 <AccountItemCount<T>>::insert(owner.clone(), 2459 <AccountItemCount<T>>::get(owner)2460 .checked_sub(1)2461 .ok_or(Error::<T>::NumOverflow)?);246224632464 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2465 if list_exists {2466 let mut list = <AddressTokens<T>>::get(collection_id, owner);2467 let item_contains = list.contains(&item_index.clone());24682469 if item_contains {2470 list.retain(|&item| item != item_index);2471 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2472 }2473 }24742475 Ok(())2476 }24772478 fn move_token_index(2479 collection_id: CollectionId,2480 item_index: TokenId,2481 old_owner: &T::AccountId,2482 new_owner: &T::AccountId,2483 ) -> DispatchResult {2484 Self::remove_token_index(collection_id, item_index, old_owner)?;2485 Self::add_token_index(collection_id, item_index, new_owner)?;24862487 Ok(())2488 }2489 2490 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2491 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24922493 Ok(())2494 }2495}2496249724982499250025012502pub type Multiplier = FixedU128;25032504type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2505250625072508#[derive(Encode, Decode, Clone, Eq, PartialEq)]2509pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25102511impl<T: Config + Send + Sync> sp_std::fmt::Debug 2512 for ChargeTransactionPayment<T>2513{2514 #[cfg(feature = "std")]2515 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2516 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2517 }2518 #[cfg(not(feature = "std"))]2519 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2520 Ok(())2521 }2522}25232524impl<T: Config> ChargeTransactionPayment<T>2525where2526 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2527 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2528 T::AccountId: AsRef<[u8]>,2529 T::AccountId: UncheckedFrom<T::Hash>,2530{2531 fn traditional_fee(2532 len: usize,2533 info: &DispatchInfoOf<T::Call>,2534 tip: BalanceOf<T>,2535 ) -> BalanceOf<T>2536 where2537 T::Call: Dispatchable<Info = DispatchInfo>,2538 {2539 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2540 }25412542 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2543 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2544 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2545 let len_saturation = max_block_length as u64 / (len as u64).max(1);2546 let coefficient: BalanceOf<T> = weight_saturation2547 .min(len_saturation)2548 .saturated_into::<BalanceOf<T>>();2549 final_fee2550 .saturating_mul(coefficient)2551 .saturated_into::<TransactionPriority>()2552 }25532554 fn withdraw_fee(2555 &self,2556 who: &T::AccountId,2557 call: &T::Call,2558 info: &DispatchInfoOf<T::Call>,2559 len: usize,2560 ) -> Result<2561 (2562 BalanceOf<T>,2563 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2564 ),2565 TransactionValidityError,2566 > {2567 let tip = self.0;25682569 let fee = Self::traditional_fee(len, info, tip);25702571 2572 if fee.is_zero() {2573 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2574 .map(|i| (fee, i));2575 }25762577 2578 2579 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2580 Some(Call::create_item(collection_id, _owner, _properties)) => {2581 let collection = <CollectionById<T>>::get(collection_id)?;25822583 2584 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25852586 let limit = collection.limits.sponsor_transfer_timeout;2587 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2588 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2589 let limit_time = last_tx_block + limit.into();2590 if block_number <= limit_time {2591 return None;2592 }2593 }2594 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25952596 2597 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2598 collection.sponsorship.sponsor()2599 .cloned()2600 } else {2601 None2602 }2603 }2604 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2605 let collection = <CollectionById<T>>::get(collection_id)?;2606 2607 let mut sponsor_transfer = false;2608 if collection.sponsorship.confirmed() {26092610 let collection_limits = collection.limits;2611 let collection_mode = collection.mode;2612 2613 2614 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2615 sponsor_transfer = match collection_mode {2616 CollectionMode::NFT => {2617 2618 2619 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2620 collection_limits.sponsor_transfer_timeout2621 } else {2622 ChainLimit::get().nft_sponsor_transfer_timeout2623 };2624 2625 let mut sponsored = true;2626 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2627 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2628 let limit_time = last_tx_block + limit.into();2629 if block_number <= limit_time {2630 sponsored = false;2631 }2632 }2633 if sponsored {2634 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2635 }26362637 sponsored2638 }2639 CollectionMode::Fungible(_) => {2640 2641 2642 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2643 collection_limits.sponsor_transfer_timeout2644 } else {2645 ChainLimit::get().fungible_sponsor_transfer_timeout2646 };2647 2648 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2649 let mut sponsored = true;2650 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2651 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2652 let limit_time = last_tx_block + limit.into();2653 if block_number <= limit_time {2654 sponsored = false;2655 }2656 }2657 if sponsored {2658 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2659 }26602661 sponsored2662 }2663 CollectionMode::ReFungible => {2664 2665 2666 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2667 collection_limits.sponsor_transfer_timeout2668 } else {2669 ChainLimit::get().refungible_sponsor_transfer_timeout2670 };2671 2672 let mut sponsored = true;2673 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2674 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2675 let limit_time = last_tx_block + limit.into();2676 if block_number <= limit_time {2677 sponsored = false;2678 }2679 }2680 if sponsored {2681 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2682 }26832684 sponsored2685 }2686 _ => {2687 false2688 },2689 };2690 }26912692 if !sponsor_transfer {2693 None2694 } else {2695 collection.sponsorship.sponsor()2696 .cloned()2697 }2698 }26992700 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2701 let mut sponsor_metadata_changes = false;27022703 let collection = <CollectionById<T>>::get(collection_id)?;27042705 if2706 collection.sponsorship.confirmed() &&2707 2708 2709 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2710 data.len() <= collection.limits.sponsored_data_size as usize2711 {2712 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2713 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27142715 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2716 .map(|last_block| block_number - last_block > rate_limit)2717 .unwrap_or(true) 2718 {2719 sponsor_metadata_changes = true;2720 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2721 }2722 }2723 }27242725 if !sponsor_metadata_changes {2726 None2727 } else {2728 collection.sponsorship.sponsor().cloned()2729 }2730 }27312732 _ => None,2733 })();27342735 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2736 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27372738 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27392740 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2741 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2742 2743 if !owned_contract && white_list_enabled {2744 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2745 return Err(InvalidTransaction::Call.into());2746 }2747 }2748 },2749 _ => {},2750 }27512752 2753 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27542755 2756 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27572758 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2759 &who,2760 code_hash,2761 salt,2762 );2763 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27642765 None2766 },27672768 2769 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27702771 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2772 &who,2773 &T::Hashing::hash(&_code),2774 _salt,2775 );27762777 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27782779 None2780 }27812782 2783 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27842785 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27862787 let mut sponsor_transfer = false;2788 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2789 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2790 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2791 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2792 let limit_time = last_tx_block + rate_limit;27932794 if block_number >= limit_time {2795 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2796 sponsor_transfer = true;2797 }2798 } else {2799 sponsor_transfer = false;2800 }2801 2802 if sponsor_transfer {2803 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2804 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2805 return Some(called_contract);2806 }2807 }2808 }28092810 None2811 },28122813 _ => None,2814 });28152816 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28172818 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2819 .map(|i| (fee, i))2820 }2821}282228232824impl<T: Config + Send + Sync> SignedExtension2825 for ChargeTransactionPayment<T>2826where2827 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2828 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2829 T::AccountId: AsRef<[u8]>,2830 T::AccountId: UncheckedFrom<T::Hash>,2831{2832 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2833 type AccountId = T::AccountId;2834 type Call = T::Call;2835 type AdditionalSigned = ();2836 type Pre = (2837 2838 BalanceOf<T>,2839 2840 Self::AccountId,2841 2842 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2843 );2844 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2845 Ok(())2846 }28472848 fn validate(2849 &self,2850 who: &Self::AccountId,2851 call: &Self::Call,2852 info: &DispatchInfoOf<Self::Call>,2853 len: usize,2854 ) -> TransactionValidity {2855 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2856 Ok(ValidTransaction {2857 priority: Self::get_priority(len, info, fee),2858 ..Default::default()2859 })2860 }28612862 fn pre_dispatch(2863 self,2864 who: &Self::AccountId,2865 call: &Self::Call,2866 info: &DispatchInfoOf<Self::Call>,2867 len: usize,2868 ) -> Result<Self::Pre, TransactionValidityError> {2869 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2870 Ok((self.0, who.clone(), imbalance))2871 }28722873 fn post_dispatch(2874 pre: Self::Pre,2875 info: &DispatchInfoOf<Self::Call>,2876 post_info: &PostDispatchInfoOf<Self::Call>,2877 len: usize,2878 _result: &DispatchResult,2879 ) -> Result<(), TransactionValidityError> {2880 let (tip, who, imbalance) = pre;2881 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2882 len as u32,2883 info,2884 post_info,2885 tip,2886 );2887 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2888 Ok(())2889 }2890}28912892