123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use codec::{Decode, Encode};17pub use frame_support::{18 construct_runtime, decl_event, decl_module, decl_storage, decl_error,19 dispatch::DispatchResult,20 ensure, fail, parameter_types,21 traits::{22 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23 Randomness, IsSubType,24 },25 weights::{26 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28 WeightToFeePolynomial, DispatchClass,29 },30 StorageValue,31};3233use frame_system::{self as system, ensure_signed, ensure_root};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 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 transaction_payment::OnChargeTransaction;4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;5556pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;57pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;58pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;59pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6061626364pub type CollectionId = u32;65pub type TokenId = u32;66pub type DecimalPoints = u8;6768#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]69#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]70pub enum CollectionMode {71 Invalid,72 NFT,73 74 Fungible(DecimalPoints),75 ReFungible,76}7778impl Default for CollectionMode {79 fn default() -> Self {80 Self::Invalid81 }82}8384impl Into<u8> for CollectionMode {85 fn into(self) -> u8 {86 match self {87 CollectionMode::Invalid => 0,88 CollectionMode::NFT => 1,89 CollectionMode::Fungible(_) => 2,90 CollectionMode::ReFungible => 3,91 }92 }93}9495#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]96#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]97pub enum AccessMode {98 Normal,99 WhiteList,100}101impl Default for AccessMode {102 fn default() -> Self {103 Self::Normal104 }105}106107#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]108#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]109pub enum SchemaVersion {110 ImageURL,111 Unique,112}113impl Default for SchemaVersion {114 fn default() -> Self {115 Self::ImageURL116 }117}118119#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]120#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]121pub struct Ownership<AccountId> {122 pub owner: AccountId,123 pub fraction: u128,124}125126#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]127#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]128pub struct CollectionType<AccountId> {129 pub owner: AccountId,130 pub mode: CollectionMode,131 pub access: AccessMode,132 pub decimal_points: DecimalPoints,133 pub name: Vec<u16>, 134 pub description: Vec<u16>, 135 pub token_prefix: Vec<u8>, 136 pub mint_mode: bool,137 pub offchain_schema: Vec<u8>,138 pub schema_version: SchemaVersion,139 pub sponsor: AccountId, 140 pub sponsor_confirmed: bool, 141 pub limits: CollectionLimits, 142 pub variable_on_chain_schema: Vec<u8>, 143 pub const_on_chain_schema: Vec<u8>, 144}145146#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]147#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]148pub struct NftItemType<AccountId> {149 pub owner: AccountId,150 pub const_data: Vec<u8>,151 pub variable_data: Vec<u8>,152}153154#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]155#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]156pub struct FungibleItemType {157 pub value: u128,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct ReFungibleItemType<AccountId> {163 pub owner: Vec<Ownership<AccountId>>,164 pub const_data: Vec<u8>,165 pub variable_data: Vec<u8>,166}167168169170171172173174175176177178179#[derive(Encode, Decode, Debug, Clone, PartialEq)]180#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]181pub struct CollectionLimits {182 pub account_token_ownership_limit: u32,183 pub sponsored_data_size: u32,184 pub token_limit: u32,185186 187 pub sponsor_transfer_timeout: u32,188 pub owner_can_transfer: bool,189 pub owner_can_destroy: bool,190}191192impl Default for CollectionLimits {193 fn default() -> CollectionLimits {194 CollectionLimits { 195 account_token_ownership_limit: 10_000_000, 196 token_limit: u32::max_value(),197 sponsored_data_size: u32::max_value(), 198 sponsor_transfer_timeout: 14400,199 owner_can_transfer: true,200 owner_can_destroy: true201 }202 }203}204205#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]206#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]207pub struct ChainLimits {208 pub collection_numbers_limit: u32,209 pub account_token_ownership_limit: u32,210 pub collections_admins_limit: u64,211 pub custom_data_limit: u32,212213 214 pub nft_sponsor_transfer_timeout: u32,215 pub fungible_sponsor_transfer_timeout: u32,216 pub refungible_sponsor_transfer_timeout: u32,217218 219 pub offchain_schema_limit: u32,220 pub variable_on_chain_schema_limit: u32,221 pub const_on_chain_schema_limit: u32,222}223224pub trait WeightInfo {225 fn create_collection() -> Weight;226 fn destroy_collection() -> Weight;227 fn add_to_white_list() -> Weight;228 fn remove_from_white_list() -> Weight;229 fn set_public_access_mode() -> Weight;230 fn set_mint_permission() -> Weight;231 fn change_collection_owner() -> Weight;232 fn add_collection_admin() -> Weight;233 fn remove_collection_admin() -> Weight;234 fn set_collection_sponsor() -> Weight;235 fn confirm_sponsorship() -> Weight;236 fn remove_collection_sponsor() -> Weight;237 fn create_item(s: usize) -> Weight;238 fn burn_item() -> Weight;239 fn transfer() -> Weight;240 fn approve() -> Weight;241 fn transfer_from() -> Weight;242 fn set_offchain_schema() -> Weight;243 fn set_const_on_chain_schema() -> Weight;244 fn set_variable_on_chain_schema() -> Weight;245 fn set_variable_meta_data() -> Weight;246 fn enable_contract_sponsoring() -> Weight;247 fn set_schema_version() -> Weight;248 fn set_chain_limits() -> Weight;249 fn set_contract_sponsoring_rate_limit() -> Weight;250 fn toggle_contract_white_list() -> Weight;251 fn add_to_contract_white_list() -> Weight;252 fn remove_from_contract_white_list() -> Weight;253 fn set_collection_limits() -> Weight;254}255256#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]257#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]258pub struct CreateNftData {259 pub const_data: Vec<u8>,260 pub variable_data: Vec<u8>,261}262263#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]264#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]265pub struct CreateFungibleData {266 pub value: u128,267}268269#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]270#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]271pub struct CreateReFungibleData {272 pub const_data: Vec<u8>,273 pub variable_data: Vec<u8>,274 pub pieces: u128,275}276277#[derive(Encode, Decode, Debug, Clone, PartialEq)]278#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]279pub enum CreateItemData {280 NFT(CreateNftData),281 Fungible(CreateFungibleData),282 ReFungible(CreateReFungibleData),283}284285impl CreateItemData {286 pub fn len(&self) -> usize {287 let len = match self {288 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),289 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),290 _ => 0291 };292 293 return len;294 }295}296297impl From<CreateNftData> for CreateItemData {298 fn from(item: CreateNftData) -> Self {299 CreateItemData::NFT(item)300 }301}302303impl From<CreateReFungibleData> for CreateItemData {304 fn from(item: CreateReFungibleData) -> Self {305 CreateItemData::ReFungible(item)306 }307}308309impl From<CreateFungibleData> for CreateItemData {310 fn from(item: CreateFungibleData) -> Self {311 CreateItemData::Fungible(item)312 }313}314315316decl_error! {317 318 pub enum Error for Module<T: Config> {319 320 TotalCollectionsLimitExceeded,321 322 CollectionDecimalPointLimitExceeded, 323 324 CollectionNameLimitExceeded, 325 326 CollectionDescriptionLimitExceeded, 327 328 CollectionTokenPrefixLimitExceeded,329 330 CollectionNotFound,331 332 TokenNotFound,333 334 AdminNotFound,335 336 NumOverflow, 337 338 AlreadyAdmin, 339 340 NoPermission,341 342 ConfirmUnsetSponsorFail,343 344 PublicMintingNotAllowed,345 346 MustBeTokenOwner,347 348 TokenValueTooLow,349 350 NftSizeLimitExceeded,351 352 ApproveNotFound,353 354 TokenValueNotEnough,355 356 ApproveRequired,357 358 AddresNotInWhiteList,359 360 CollectionAdminsLimitExceeded,361 362 AddressOwnershipLimitExceeded,363 364 EmptyArgument,365 366 TokenConstDataLimitExceeded,367 368 TokenVariableDataLimitExceeded,369 370 NotNftDataUsedToMintNftCollectionToken,371 372 NotFungibleDataUsedToMintFungibleCollectionToken,373 374 NotReFungibleDataUsedToMintReFungibleCollectionToken,375 376 UnexpectedCollectionType,377 378 CantStoreMetadataInFungibleTokens,379 380 CollectionTokenLimitExceeded,381 382 AccountTokenLimitExceeded,383 384 CollectionLimitBoundsExceeded,385 386 SchemaDataLimitExceeded,387 388 WrongRefungiblePieces389 }390}391392pub trait Config: system::Config + Sized + transaction_payment::Config + pallet_contracts::Config {393 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;394395 396 type WeightInfo: WeightInfo;397}398399#[cfg(feature = "runtime-benchmarks")]400mod benchmarking;401402403404decl_storage! {405 trait Store for Module<T: Config> as Nft {406407 408 NextCollectionID: CollectionId;409 CreatedCollectionCount: u32;410 ChainVersion: u64;411 ItemListIndex: map hasher(identity) CollectionId => TokenId;412413 414 pub ChainLimit get(fn chain_limit) config(): ChainLimits;415416 417 CollectionCount: u32;418 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;419420 421 pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;422 pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;423 pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;424425 426 pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;427428 429 pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;430431 432 pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;433 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;434 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;435436 437 pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;438439 440 pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;441 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;442 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;443 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;444445 446 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;447 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;448 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;449 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;450 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 451 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 452 }453 add_extra_genesis {454 build(|config: &GenesisConfig<T>| {455 456 for (_num, _c) in &config.collection {457 <Module<T>>::init_collection(_c);458 }459460 for (_num, _c, _i) in &config.nft_item_id {461 <Module<T>>::init_nft_token(*_c, _i);462 }463464 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {465 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);466 }467468 for (_num, _c, _i) in &config.refungible_item_id {469 <Module<T>>::init_refungible_token(*_c, _i);470 }471 })472 }473}474475decl_event!(476 pub enum Event<T>477 where478 AccountId = <T as system::Config>::AccountId,479 {480 481 482 483 484 485 486 487 488 489 Created(CollectionId, u8, AccountId),490491 492 493 494 495 496 497 498 499 500 ItemCreated(CollectionId, TokenId, AccountId),501502 503 504 505 506 507 508 509 ItemDestroyed(CollectionId, TokenId),510 }511);512513decl_module! {514 pub struct Module<T: Config> for enum Call 515 where 516 origin: T::Origin517 {518 fn deposit_event() = default;519 type Error = Error<T>;520521 fn on_initialize(now: T::BlockNumber) -> Weight {522523 if ChainVersion::get() < 2524 {525 let value = NextCollectionID::get();526 CreatedCollectionCount::put(value);527 ChainVersion::put(2);528 }529530 0531 }532533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 #[weight = <T as Config>::WeightInfo::create_collection()]550 pub fn create_collection(origin,551 collection_name: Vec<u16>,552 collection_description: Vec<u16>,553 token_prefix: Vec<u8>,554 mode: CollectionMode) -> DispatchResult {555556 557 let who = ensure_signed(origin)?;558559 let decimal_points = match mode {560 CollectionMode::Fungible(points) => points,561 _ => 0562 };563564 565 ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);566567 568 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);569 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);570 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);571 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);572573 574 let next_id = CreatedCollectionCount::get()575 .checked_add(1)576 .ok_or(Error::<T>::NumOverflow)?;577578 579 let total = CollectionCount::get()580 .checked_add(1)581 .ok_or(Error::<T>::NumOverflow)?;582583 CreatedCollectionCount::put(next_id);584 CollectionCount::put(total);585586 587 let new_collection = CollectionType {588 owner: who.clone(),589 name: collection_name,590 mode: mode.clone(),591 mint_mode: false,592 access: AccessMode::Normal,593 description: collection_description,594 decimal_points: decimal_points,595 token_prefix: token_prefix,596 offchain_schema: Vec::new(),597 schema_version: SchemaVersion::ImageURL,598 sponsor: T::AccountId::default(),599 sponsor_confirmed: false,600 variable_on_chain_schema: Vec::new(),601 const_on_chain_schema: Vec::new(),602 limits: CollectionLimits::default()603 };604605 606 <Collection<T>>::insert(next_id, new_collection);607608 609 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));610611 Ok(())612 }613614 615 616 617 618 619 620 621 622 623 #[weight = <T as Config>::WeightInfo::destroy_collection()]624 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {625626 let sender = ensure_signed(origin)?;627 Self::check_owner_permissions(collection_id, sender)?;628629 <AddressTokens<T>>::remove_prefix(collection_id);630 <Allowances<T>>::remove_prefix(collection_id);631 <Balance<T>>::remove_prefix(collection_id);632 <ItemListIndex>::remove(collection_id);633 <AdminList<T>>::remove(collection_id);634 <Collection<T>>::remove(collection_id);635 <WhiteList<T>>::remove_prefix(collection_id);636637 <NftItemList<T>>::remove_prefix(collection_id);638 <FungibleItemList<T>>::remove_prefix(collection_id);639 <ReFungibleItemList<T>>::remove_prefix(collection_id);640641 <NftTransferBasket<T>>::remove_prefix(collection_id);642 <FungibleTransferBasket<T>>::remove_prefix(collection_id);643 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);644645 if CollectionCount::get() > 0646 {647 648 let total = CollectionCount::get()649 .checked_sub(1)650 .ok_or(Error::<T>::NumOverflow)?;651652 CollectionCount::put(total);653 }654655 Ok(())656 }657658 659 660 661 662 663 664 665 666 667 668 669 670 #[weight = <T as Config>::WeightInfo::add_to_white_list()]671 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{672673 let sender = ensure_signed(origin)?;674 Self::check_owner_or_admin_permissions(collection_id, sender)?;675676 <WhiteList<T>>::insert(collection_id, address, true);677 678 Ok(())679 }680681 682 683 684 685 686 687 688 689 690 691 692 693 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]694 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{695696 let sender = ensure_signed(origin)?;697 Self::check_owner_or_admin_permissions(collection_id, sender)?;698699 <WhiteList<T>>::remove(collection_id, address);700701 Ok(())702 }703704 705 706 707 708 709 710 711 712 713 714 715 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]716 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult717 {718 let sender = ensure_signed(origin)?;719720 Self::check_owner_permissions(collection_id, sender)?;721 let mut target_collection = <Collection<T>>::get(collection_id);722 target_collection.access = mode;723 <Collection<T>>::insert(collection_id, target_collection);724725 Ok(())726 }727728 729 730 731 732 733 734 735 736 737 738 739 740 741 #[weight = <T as Config>::WeightInfo::set_mint_permission()]742 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult743 {744 let sender = ensure_signed(origin)?;745746 Self::check_owner_permissions(collection_id, sender)?;747 let mut target_collection = <Collection<T>>::get(collection_id);748 target_collection.mint_mode = mint_permission;749 <Collection<T>>::insert(collection_id, target_collection);750751 Ok(())752 }753754 755 756 757 758 759 760 761 762 763 764 765 #[weight = <T as Config>::WeightInfo::change_collection_owner()]766 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {767768 let sender = ensure_signed(origin)?;769 Self::check_owner_permissions(collection_id, sender)?;770 let mut target_collection = <Collection<T>>::get(collection_id);771 target_collection.owner = new_owner;772 <Collection<T>>::insert(collection_id, target_collection);773774 Ok(())775 }776777 778 779 780 781 782 783 784 785 786 787 788 789 790 #[weight = <T as Config>::WeightInfo::add_collection_admin()]791 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {792793 let sender = ensure_signed(origin)?;794 Self::check_owner_or_admin_permissions(collection_id, sender)?;795 let mut admin_arr: Vec<T::AccountId> = Vec::new();796797 if <AdminList<T>>::contains_key(collection_id)798 {799 admin_arr = <AdminList<T>>::get(collection_id);800 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);801 }802803 804 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);805806 admin_arr.push(new_admin_id);807 <AdminList<T>>::insert(collection_id, admin_arr);808809 Ok(())810 }811812 813 814 815 816 817 818 819 820 821 822 823 824 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]825 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {826827 let sender = ensure_signed(origin)?;828 Self::check_owner_or_admin_permissions(collection_id, sender)?;829 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);830831 let mut admin_arr = <AdminList<T>>::get(collection_id);832 admin_arr.retain(|i| *i != account_id);833 <AdminList<T>>::insert(collection_id, admin_arr);834835 Ok(())836 }837838 839 840 841 842 843 844 845 846 847 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]848 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {849850 let sender = ensure_signed(origin)?;851 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);852853 let mut target_collection = <Collection<T>>::get(collection_id);854 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);855856 target_collection.sponsor = new_sponsor;857 target_collection.sponsor_confirmed = false;858 <Collection<T>>::insert(collection_id, target_collection);859860 Ok(())861 }862863 864 865 866 867 868 869 870 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]871 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {872873 let sender = ensure_signed(origin)?;874 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);875876 let mut target_collection = <Collection<T>>::get(collection_id);877 ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);878879 target_collection.sponsor_confirmed = true;880 <Collection<T>>::insert(collection_id, target_collection);881882 Ok(())883 }884885 886 887 888 889 890 891 892 893 894 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]895 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {896897 let sender = ensure_signed(origin)?;898 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);899900 let mut target_collection = <Collection<T>>::get(collection_id);901 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);902903 target_collection.sponsor = T::AccountId::default();904 target_collection.sponsor_confirmed = false;905 <Collection<T>>::insert(collection_id, target_collection);906907 Ok(())908 }909910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933934 #[weight = <T as Config>::WeightInfo::create_item(data.len())]935 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {936937 let sender = ensure_signed(origin)?;938939 Self::collection_exists(collection_id)?;940941 let target_collection = <Collection<T>>::get(collection_id);942943 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;944 Self::validate_create_item_args(&target_collection, &data)?;945 Self::create_item_no_validation(collection_id, owner, data)?;946947 Ok(())948 }949950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()969 .map(|data| { data.len() })970 .sum())]971 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {972973 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);974 let sender = ensure_signed(origin)?;975976 Self::collection_exists(collection_id)?;977 let target_collection = <Collection<T>>::get(collection_id);978979 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;980981 for data in &items_data {982 Self::validate_create_item_args(&target_collection, data)?;983 }984 for data in &items_data {985 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;986 }987988 Ok(())989 }990991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 #[weight = <T as Config>::WeightInfo::burn_item()]1005 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10061007 let sender = ensure_signed(origin)?;1008 Self::collection_exists(collection_id)?;10091010 1011 let target_collection = <Collection<T>>::get(collection_id);1012 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1013 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1014 Error::<T>::NoPermission);10151016 if target_collection.access == AccessMode::WhiteList {1017 Self::check_white_list(collection_id, &sender)?;1018 }10191020 match target_collection.mode1021 {1022 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1023 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1024 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1025 _ => ()1026 };10271028 1029 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10301031 Ok(())1032 }10331034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 #[weight = <T as Config>::WeightInfo::transfer()]1058 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1059 let sender = ensure_signed(origin)?;1060 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1061 }10621063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 #[weight = <T as Config>::WeightInfo::approve()]1079 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {10801081 let sender = ensure_signed(origin)?;10821083 Self::collection_exists(collection_id)?;1084 Self::token_exists(collection_id, item_id, &sender)?;10851086 1087 let target_collection = <Collection<T>>::get(collection_id);1088 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1089 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1090 Error::<T>::NoPermission);10911092 if target_collection.access == AccessMode::WhiteList {1093 Self::check_white_list(collection_id, &sender)?;1094 Self::check_white_list(collection_id, &spender)?;1095 }10961097 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1098 let mut allowance: u128 = amount;1099 if allowance_exists {1100 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1101 }1102 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11031104 Ok(())1105 }1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 #[weight = <T as Config>::WeightInfo::transfer_from()]1127 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11281129 let sender = ensure_signed(origin)?;1130 let mut appoved_transfer = false;11311132 1133 let mut approval: u128 = 0;1134 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1135 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1136 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1137 appoved_transfer = true;1138 }11391140 let target_collection = <Collection<T>>::get(collection_id);11411142 1143 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11441145 1146 ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1147 Error::<T>::NoPermission);11481149 if target_collection.access == AccessMode::WhiteList {1150 Self::check_white_list(collection_id, &sender)?;1151 Self::check_white_list(collection_id, &recipient)?;1152 }11531154 1155 if approval.checked_sub(value).unwrap_or(0) > 0 {1156 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1157 }1158 else {1159 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1160 }11611162 match target_collection.mode1163 {1164 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1165 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1166 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1167 _ => ()1168 };11691170 Ok(())1171 }11721173 1174 11751176 1177 1178 1179 11801181 11821183 11841185 1186 11871188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1201 pub fn set_variable_meta_data (1202 origin,1203 collection_id: CollectionId,1204 item_id: TokenId,1205 data: Vec<u8>1206 ) -> DispatchResult {1207 let sender = ensure_signed(origin)?;1208 1209 Self::collection_exists(collection_id)?;1210 Self::token_exists(collection_id, item_id, &sender)?;12111212 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12131214 1215 let target_collection = <Collection<T>>::get(collection_id);1216 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1217 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1218 Error::<T>::NoPermission);12191220 match target_collection.mode1221 {1222 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1223 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1224 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1225 _ => fail!(Error::<T>::UnexpectedCollectionType)1226 };12271228 Ok(())1229 }1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 #[weight = <T as Config>::WeightInfo::set_schema_version()]1246 pub fn set_schema_version(1247 origin,1248 collection_id: CollectionId,1249 version: SchemaVersion1250 ) -> DispatchResult {1251 let sender = ensure_signed(origin)?;1252 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1253 let mut target_collection = <Collection<T>>::get(collection_id);1254 target_collection.schema_version = version;1255 <Collection<T>>::insert(collection_id, target_collection);12561257 Ok(())1258 }12591260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1273 pub fn set_offchain_schema(1274 origin,1275 collection_id: CollectionId,1276 schema: Vec<u8>1277 ) -> DispatchResult {1278 let sender = ensure_signed(origin)?;1279 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12801281 1282 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");12831284 let mut target_collection = <Collection<T>>::get(collection_id);1285 target_collection.offchain_schema = schema;1286 <Collection<T>>::insert(collection_id, target_collection);12871288 Ok(())1289 }12901291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1304 pub fn set_const_on_chain_schema (1305 origin,1306 collection_id: CollectionId,1307 schema: Vec<u8>1308 ) -> DispatchResult {1309 let sender = ensure_signed(origin)?;1310 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13111312 1313 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13141315 let mut target_collection = <Collection<T>>::get(collection_id);1316 target_collection.const_on_chain_schema = schema;1317 <Collection<T>>::insert(collection_id, target_collection);13181319 Ok(())1320 }13211322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1335 pub fn set_variable_on_chain_schema (1336 origin,1337 collection_id: CollectionId,1338 schema: Vec<u8>1339 ) -> DispatchResult {1340 let sender = ensure_signed(origin)?;1341 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13421343 1344 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");13451346 let mut target_collection = <Collection<T>>::get(collection_id);1347 target_collection.variable_on_chain_schema = schema;1348 <Collection<T>>::insert(collection_id, target_collection);13491350 Ok(())1351 }13521353 1354 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1355 pub fn set_chain_limits(1356 origin,1357 limits: ChainLimits1358 ) -> DispatchResult {13591360 #[cfg(not(feature = "runtime-benchmarks"))]1361 ensure_root(origin)?;13621363 <ChainLimit>::put(limits);1364 Ok(())1365 }13661367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1379 pub fn enable_contract_sponsoring(1380 origin,1381 contract_address: T::AccountId,1382 enable: bool1383 ) -> DispatchResult {13841385 let sender = ensure_signed(origin)?;13861387 #[cfg(feature = "runtime-benchmarks")]1388 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13891390 Self::ensure_contract_owned(sender, &contract_address)?;13911392 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1393 Ok(())1394 }13951396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1414 pub fn set_contract_sponsoring_rate_limit(1415 origin,1416 contract_address: T::AccountId,1417 rate_limit: T::BlockNumber1418 ) -> DispatchResult {1419 let sender = ensure_signed(origin)?;14201421 #[cfg(feature = "runtime-benchmarks")]1422 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14231424 Self::ensure_contract_owned(sender, &contract_address)?;1425 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1426 Ok(())1427 }14281429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1441 pub fn toggle_contract_white_list(1442 origin,1443 contract_address: T::AccountId,1444 enable: bool1445 ) -> DispatchResult {1446 let sender = ensure_signed(origin)?;14471448 #[cfg(feature = "runtime-benchmarks")]1449 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14501451 Self::ensure_contract_owned(sender, &contract_address)?;1452 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1453 Ok(())1454 }1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1468 pub fn add_to_contract_white_list(1469 origin,1470 contract_address: T::AccountId,1471 account_address: T::AccountId1472 ) -> DispatchResult {1473 let sender = ensure_signed(origin)?;14741475 #[cfg(feature = "runtime-benchmarks")]1476 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1477 1478 Self::ensure_contract_owned(sender, &contract_address)?; 1479 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1480 Ok(())1481 }14821483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1495 pub fn remove_from_contract_white_list(1496 origin,1497 contract_address: T::AccountId,1498 account_address: T::AccountId1499 ) -> DispatchResult {1500 let sender = ensure_signed(origin)?;15011502 #[cfg(feature = "runtime-benchmarks")]1503 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15041505 Self::ensure_contract_owned(sender, &contract_address)?;1506 <ContractWhiteList<T>>::remove(contract_address, account_address);1507 Ok(())1508 }15091510 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1511 pub fn set_collection_limits(1512 origin,1513 collection_id: u32,1514 limits: CollectionLimits,1515 ) -> DispatchResult {1516 let sender = ensure_signed(origin)?;1517 Self::check_owner_permissions(collection_id, sender.clone())?;1518 let mut target_collection = <Collection<T>>::get(collection_id);1519 let chain_limits = ChainLimit::get();1520 let climits = target_collection.limits;15211522 1523 ensure!(limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1524 limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP, 1525 Error::<T>::CollectionLimitBoundsExceeded);15261527 1528 ensure!(climits.token_limit > limits.token_limit && 1529 limits.token_limit <= chain_limits.account_token_ownership_limit, 1530 Error::<T>::AccountTokenLimitExceeded);15311532 target_collection.limits = limits;1533 <Collection<T>>::insert(collection_id, target_collection);15341535 Ok(())1536 } 1537 }1538}15391540impl<T: Config> Module<T> {15411542 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {15431544 let target_collection = <Collection<T>>::get(collection_id);15451546 1547 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;15481549 1550 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1551 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1552 Error::<T>::NoPermission);15531554 if target_collection.access == AccessMode::WhiteList {1555 Self::check_white_list(collection_id, &sender)?;1556 Self::check_white_list(collection_id, &recipient)?;1557 }15581559 match target_collection.mode1560 {1561 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1562 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1563 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1564 _ => ()1565 };15661567 Ok(())1568 }156915701571 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {15721573 1574 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1575 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1576 1577 Ok(())1578 }15791580 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {15811582 1583 let total_items: u32 = ItemListIndex::get(collection_id);1584 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1585 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1586 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);15871588 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1589 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1590 Self::check_white_list(collection_id, owner)?;1591 Self::check_white_list(collection_id, sender)?;1592 }15931594 Ok(())1595 }15961597 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1598 match target_collection.mode1599 {1600 CollectionMode::NFT => {1601 if let CreateItemData::NFT(data) = data {1602 1603 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1604 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1605 } else {1606 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1607 }1608 },1609 CollectionMode::Fungible(_) => {1610 if let CreateItemData::Fungible(_) = data {1611 } else {1612 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1613 }1614 },1615 CollectionMode::ReFungible => {1616 if let CreateItemData::ReFungible(data) = data {16171618 1619 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1620 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16211622 1623 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1624 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1625 } else {1626 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1627 }1628 },1629 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1630 };16311632 Ok(())1633 }16341635 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1636 match data1637 {1638 CreateItemData::NFT(data) => {1639 let item = NftItemType {1640 owner: owner.clone(),1641 const_data: data.const_data,1642 variable_data: data.variable_data1643 };16441645 Self::add_nft_item(collection_id, item)?;1646 },1647 CreateItemData::Fungible(data) => {1648 Self::add_fungible_item(collection_id, &owner, data.value)?;1649 },1650 CreateItemData::ReFungible(data) => {1651 let mut owner_list = Vec::new();1652 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});16531654 let item = ReFungibleItemType {1655 owner: owner_list,1656 const_data: data.const_data,1657 variable_data: data.variable_data1658 };16591660 Self::add_refungible_item(collection_id, item)?;1661 }1662 };16631664 1665 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id), owner));16661667 Ok(())1668 }16691670 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {16711672 1673 let mut balance: u128 = 0;1674 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1675 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1676 } 16771678 1679 let item = FungibleItemType {1680 value: balance + value1681 };1682 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);16831684 1685 let new_balance = <Balance<T>>::get(collection_id, owner)1686 .checked_add(value)1687 .ok_or(Error::<T>::NumOverflow)?;1688 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);16891690 Ok(())1691 }16921693 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1694 let current_index = <ItemListIndex>::get(collection_id)1695 .checked_add(1)1696 .ok_or(Error::<T>::NumOverflow)?;1697 let itemcopy = item.clone();16981699 let value = item.owner.first().unwrap().fraction;1700 let owner = item.owner.first().unwrap().owner.clone();17011702 Self::add_token_index(collection_id, current_index, &owner)?;17031704 <ItemListIndex>::insert(collection_id, current_index);1705 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17061707 1708 let new_balance = <Balance<T>>::get(collection_id, &owner)1709 .checked_add(value)1710 .ok_or(Error::<T>::NumOverflow)?;1711 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17121713 Ok(())1714 }17151716 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1717 let current_index = <ItemListIndex>::get(collection_id)1718 .checked_add(1)1719 .ok_or(Error::<T>::NumOverflow)?;17201721 let item_owner = item.owner.clone();1722 Self::add_token_index(collection_id, current_index, &item.owner)?;17231724 <ItemListIndex>::insert(collection_id, current_index);1725 <NftItemList<T>>::insert(collection_id, current_index, item);17261727 1728 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1729 .checked_add(1)1730 .ok_or(Error::<T>::NumOverflow)?;1731 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17321733 Ok(())1734 }17351736 fn burn_refungible_item(1737 collection_id: CollectionId,1738 item_id: TokenId,1739 owner: &T::AccountId,1740 ) -> DispatchResult {1741 ensure!(1742 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1743 Error::<T>::TokenNotFound1744 );1745 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1746 let rft_balance = token1747 .owner1748 .iter()1749 .filter(|&i| i.owner == *owner)1750 .next()1751 .unwrap();1752 Self::remove_token_index(collection_id, item_id, owner)?;17531754 1755 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1756 .checked_sub(rft_balance.fraction)1757 .ok_or(Error::<T>::NumOverflow)?;1758 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);17591760 1761 let index = token1762 .owner1763 .iter()1764 .position(|i| i.owner == *owner)1765 .unwrap();1766 token.owner.remove(index);1767 let owner_count = token.owner.len();17681769 1770 if owner_count == 0 {1771 <ReFungibleItemList<T>>::remove(collection_id, item_id);1772 }1773 else {1774 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1775 }17761777 Ok(())1778 }17791780 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1781 ensure!(1782 <NftItemList<T>>::contains_key(collection_id, item_id),1783 Error::<T>::TokenNotFound1784 );1785 let item = <NftItemList<T>>::get(collection_id, item_id);1786 Self::remove_token_index(collection_id, item_id, &item.owner)?;17871788 1789 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1790 .checked_sub(1)1791 .ok_or(Error::<T>::NumOverflow)?;1792 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1793 <NftItemList<T>>::remove(collection_id, item_id);17941795 Ok(())1796 }17971798 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1799 ensure!(1800 <FungibleItemList<T>>::contains_key(collection_id, owner),1801 Error::<T>::TokenNotFound1802 );1803 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1804 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18051806 1807 let new_balance = <Balance<T>>::get(collection_id, owner)1808 .checked_sub(value)1809 .ok_or(Error::<T>::NumOverflow)?;1810 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18111812 if balance.value - value > 0 {1813 balance.value -= value;1814 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1815 }1816 else {1817 <FungibleItemList<T>>::remove(collection_id, owner);1818 }18191820 Ok(())1821 }18221823 fn collection_exists(collection_id: CollectionId) -> DispatchResult {1824 ensure!(1825 <Collection<T>>::contains_key(collection_id),1826 Error::<T>::CollectionNotFound1827 );1828 Ok(())1829 }18301831 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1832 Self::collection_exists(collection_id)?;18331834 let target_collection = <Collection<T>>::get(collection_id);1835 ensure!(1836 subject == target_collection.owner,1837 Error::<T>::NoPermission1838 );18391840 Ok(())1841 }18421843 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1844 let target_collection = <Collection<T>>::get(collection_id);1845 let mut result: bool = subject == target_collection.owner;1846 let exists = <AdminList<T>>::contains_key(collection_id);18471848 if !result & exists {1849 if <AdminList<T>>::get(collection_id).contains(&subject) {1850 result = true1851 }1852 }18531854 result1855 }18561857 fn check_owner_or_admin_permissions(1858 collection_id: CollectionId,1859 subject: T::AccountId,1860 ) -> DispatchResult {1861 Self::collection_exists(collection_id)?;1862 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());18631864 ensure!(1865 result,1866 Error::<T>::NoPermission1867 );1868 Ok(())1869 }18701871 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1872 let target_collection = <Collection<T>>::get(collection_id);18731874 match target_collection.mode {1875 CollectionMode::NFT => {1876 <NftItemList<T>>::get(collection_id, item_id).owner == subject1877 }1878 CollectionMode::Fungible(_) => {1879 <FungibleItemList<T>>::contains_key(collection_id, &subject)1880 }1881 CollectionMode::ReFungible => {1882 <ReFungibleItemList<T>>::get(collection_id, item_id)1883 .owner1884 .iter()1885 .any(|i| i.owner == subject)1886 }1887 CollectionMode::Invalid => false,1888 }1889 }18901891 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1892 let mes = Error::<T>::AddresNotInWhiteList;1893 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);18941895 Ok(())1896 }18971898 1899 1900 fn token_exists(1901 collection_id: CollectionId,1902 item_id: TokenId,1903 owner: &T::AccountId1904 ) -> DispatchResult {1905 let target_collection = <Collection<T>>::get(collection_id);1906 let exists = match target_collection.mode1907 {1908 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1909 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),1910 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1911 _ => false1912 };19131914 ensure!(exists == true, Error::<T>::TokenNotFound);1915 Ok(())1916 }19171918 fn transfer_fungible(1919 collection_id: CollectionId,1920 value: u128,1921 owner: &T::AccountId,1922 recipient: &T::AccountId,1923 ) -> DispatchResult {1924 Self::token_exists(collection_id, 0, owner)?;19251926 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1927 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19281929 1930 Self::add_fungible_item(collection_id, recipient, value)?;19311932 1933 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);19341935 1936 if balance.value == value {1937 <FungibleItemList<T>>::remove(collection_id, owner);1938 }1939 else {1940 balance.value -= value;1941 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1942 }19431944 Ok(())1945 }19461947 fn transfer_refungible(1948 collection_id: CollectionId,1949 item_id: TokenId,1950 value: u128,1951 owner: T::AccountId,1952 new_owner: T::AccountId,1953 ) -> DispatchResult {1954 Self::token_exists(collection_id, item_id, &owner)?;19551956 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1957 let item = full_item1958 .owner1959 .iter()1960 .filter(|i| i.owner == owner)1961 .next()1962 .ok_or(Error::<T>::NumOverflow)?;1963 let amount = item.fraction;19641965 ensure!(amount >= value, Error::<T>::TokenValueTooLow);19661967 1968 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1969 .checked_sub(value)1970 .ok_or(Error::<T>::NumOverflow)?;1971 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19721973 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())1974 .checked_add(value)1975 .ok_or(Error::<T>::NumOverflow)?;1976 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);19771978 let old_owner = item.owner.clone();1979 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19801981 1982 if amount == value && !new_owner_has_account {1983 1984 1985 let mut new_full_item = full_item.clone();1986 new_full_item1987 .owner1988 .iter_mut()1989 .find(|i| i.owner == owner)1990 .unwrap()1991 .owner = new_owner.clone();1992 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);19931994 1995 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;1996 } else {1997 let mut new_full_item = full_item.clone();1998 new_full_item1999 .owner2000 .iter_mut()2001 .find(|i| i.owner == owner)2002 .unwrap()2003 .fraction -= value;20042005 2006 if new_owner_has_account {2007 2008 new_full_item2009 .owner2010 .iter_mut()2011 .find(|i| i.owner == new_owner)2012 .unwrap()2013 .fraction += value;2014 } else {2015 2016 new_full_item.owner.push(Ownership {2017 owner: new_owner.clone(),2018 fraction: value,2019 });2020 Self::add_token_index(collection_id, item_id, &new_owner)?;2021 }20222023 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2024 }20252026 Ok(())2027 }20282029 fn transfer_nft(2030 collection_id: CollectionId,2031 item_id: TokenId,2032 sender: T::AccountId,2033 new_owner: T::AccountId,2034 ) -> DispatchResult {2035 Self::token_exists(collection_id, item_id, &sender)?;20362037 let mut item = <NftItemList<T>>::get(collection_id, item_id);20382039 ensure!(2040 sender == item.owner,2041 Error::<T>::MustBeTokenOwner2042 );20432044 2045 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2046 .checked_sub(1)2047 .ok_or(Error::<T>::NumOverflow)?;2048 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20492050 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2051 .checked_add(1)2052 .ok_or(Error::<T>::NumOverflow)?;2053 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20542055 2056 let old_owner = item.owner.clone();2057 item.owner = new_owner.clone();2058 <NftItemList<T>>::insert(collection_id, item_id, item);20592060 2061 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;20622063 Ok(())2064 }2065 2066 fn set_re_fungible_variable_data(2067 collection_id: CollectionId,2068 item_id: TokenId,2069 data: Vec<u8>2070 ) -> DispatchResult {2071 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);20722073 item.variable_data = data;20742075 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);20762077 Ok(())2078 }20792080 fn set_nft_variable_data(2081 collection_id: CollectionId,2082 item_id: TokenId,2083 data: Vec<u8>2084 ) -> DispatchResult {2085 let mut item = <NftItemList<T>>::get(collection_id, item_id);2086 2087 item.variable_data = data;20882089 <NftItemList<T>>::insert(collection_id, item_id, item);2090 2091 Ok(())2092 }20932094 fn init_collection(item: &CollectionType<T::AccountId>) {2095 2096 assert!(2097 item.decimal_points <= MAX_DECIMAL_POINTS,2098 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2099 );2100 assert!(2101 item.name.len() <= 64,2102 "Collection name can not be longer than 63 char"2103 );2104 assert!(2105 item.name.len() <= 256,2106 "Collection description can not be longer than 255 char"2107 );2108 assert!(2109 item.token_prefix.len() <= 16,2110 "Token prefix can not be longer than 15 char"2111 );21122113 2114 let next_id = CreatedCollectionCount::get()2115 .checked_add(1)2116 .unwrap();21172118 CreatedCollectionCount::put(next_id);2119 }21202121 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2122 let current_index = <ItemListIndex>::get(collection_id)2123 .checked_add(1)2124 .unwrap();21252126 let item_owner = item.owner.clone();2127 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();21282129 <ItemListIndex>::insert(collection_id, current_index);21302131 2132 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2133 .checked_add(1)2134 .unwrap();2135 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2136 }21372138 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2139 let current_index = <ItemListIndex>::get(collection_id)2140 .checked_add(1)2141 .unwrap();21422143 Self::add_token_index(collection_id, current_index, owner).unwrap();21442145 <ItemListIndex>::insert(collection_id, current_index);21462147 2148 let new_balance = <Balance<T>>::get(collection_id, owner)2149 .checked_add(item.value)2150 .unwrap();2151 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2152 }21532154 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2155 let current_index = <ItemListIndex>::get(collection_id)2156 .checked_add(1)2157 .unwrap();21582159 let value = item.owner.first().unwrap().fraction;2160 let owner = item.owner.first().unwrap().owner.clone();21612162 Self::add_token_index(collection_id, current_index, &owner).unwrap();21632164 <ItemListIndex>::insert(collection_id, current_index);21652166 2167 let new_balance = <Balance<T>>::get(collection_id, &owner)2168 .checked_add(value)2169 .unwrap();2170 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2171 }21722173 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {21742175 2176 if <AccountItemCount<T>>::contains_key(owner) {21772178 2179 let count = <AccountItemCount<T>>::get(owner);2180 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);21812182 <AccountItemCount<T>>::insert(owner.clone(), count2183 .checked_add(1)2184 .ok_or(Error::<T>::NumOverflow)?);2185 }2186 else {2187 <AccountItemCount<T>>::insert(owner.clone(), 1);2188 }21892190 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2191 if list_exists {2192 let mut list = <AddressTokens<T>>::get(collection_id, owner);2193 let item_contains = list.contains(&item_index.clone());21942195 if !item_contains {2196 list.push(item_index.clone());2197 }21982199 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2200 } else {2201 let mut itm = Vec::new();2202 itm.push(item_index.clone());2203 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2204 }22052206 Ok(())2207 }22082209 fn remove_token_index(2210 collection_id: CollectionId,2211 item_index: TokenId,2212 owner: &T::AccountId,2213 ) -> DispatchResult {22142215 2216 <AccountItemCount<T>>::insert(owner.clone(), 2217 <AccountItemCount<T>>::get(owner)2218 .checked_sub(1)2219 .ok_or(Error::<T>::NumOverflow)?);222022212222 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2223 if list_exists {2224 let mut list = <AddressTokens<T>>::get(collection_id, owner);2225 let item_contains = list.contains(&item_index.clone());22262227 if item_contains {2228 list.retain(|&item| item != item_index);2229 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2230 }2231 }22322233 Ok(())2234 }22352236 fn move_token_index(2237 collection_id: CollectionId,2238 item_index: TokenId,2239 old_owner: &T::AccountId,2240 new_owner: &T::AccountId,2241 ) -> DispatchResult {2242 Self::remove_token_index(collection_id, item_index, old_owner)?;2243 Self::add_token_index(collection_id, item_index, new_owner)?;22442245 Ok(())2246 }2247 2248 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2249 if <ContractOwner<T>>::contains_key(contract.clone()) {2250 let owner = <ContractOwner<T>>::get(contract);2251 ensure!(account == owner, Error::<T>::NoPermission);2252 } else {2253 fail!(Error::<T>::NoPermission);2254 }22552256 Ok(())2257 }2258}2259226022612262226322642265pub type Multiplier = FixedU128;22662267type BalanceOf<T> = <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::Balance;2268226922702271#[derive(Encode, Decode, Clone, Eq, PartialEq)]2272pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);22732274impl<T: Config + Send + Sync> sp_std::fmt::Debug 2275 for ChargeTransactionPayment<T>2276{2277 #[cfg(feature = "std")]2278 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2279 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2280 }2281 #[cfg(not(feature = "std"))]2282 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2283 Ok(())2284 }2285}22862287impl<T: Config> ChargeTransactionPayment<T>2288where2289 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2290 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2291 T::AccountId: AsRef<[u8]>,2292 T::AccountId: UncheckedFrom<T::Hash>,2293{2294 fn traditional_fee(2295 len: usize,2296 info: &DispatchInfoOf<T::Call>,2297 tip: BalanceOf<T>,2298 ) -> BalanceOf<T>2299 where2300 T::Call: Dispatchable<Info = DispatchInfo>,2301 {2302 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2303 }23042305 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2306 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2307 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2308 let len_saturation = max_block_length as u64 / (len as u64).max(1);2309 let coefficient: BalanceOf<T> = weight_saturation2310 .min(len_saturation)2311 .saturated_into::<BalanceOf<T>>();2312 final_fee2313 .saturating_mul(coefficient)2314 .saturated_into::<TransactionPriority>()2315 }23162317 fn withdraw_fee(2318 &self,2319 who: &T::AccountId,2320 call: &T::Call,2321 info: &DispatchInfoOf<T::Call>,2322 len: usize,2323 ) -> Result<2324 (2325 BalanceOf<T>,2326 <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2327 ),2328 TransactionValidityError,2329 > {2330 let tip = self.0;23312332 2333 2334 2335 2336 2337 2338 2339 let fee = Self::traditional_fee(len, info, tip);23402341 2342 if fee.is_zero() {2343 return <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2344 .map(|i| (fee, i));2345 }23462347 2348 2349 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2350 Some(Call::create_item(collection_id, _owner, _properties)) => {23512352 2353 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;23542355 let limit = <Collection<T>>::get(collection_id).limits.sponsor_transfer_timeout;2356 let mut sponsored = true;2357 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2358 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2359 let limit_time = last_tx_block + limit.into();2360 if block_number <= limit_time {2361 sponsored = false;2362 }2363 }2364 if sponsored {2365 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2366 }23672368 2369 if (<Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)) &&2370 (<Collection<T>>::get(collection_id).sponsor_confirmed) &&2371 (sponsored)2372 {2373 <Collection<T>>::get(collection_id).sponsor2374 } else {2375 T::AccountId::default()2376 }2377 }2378 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2379 2380 let mut sponsor_transfer = false;2381 if <Collection<T>>::get(collection_id).sponsor_confirmed {23822383 let collection_limits = <Collection<T>>::get(collection_id).limits;2384 let collection_mode = <Collection<T>>::get(collection_id).mode;2385 2386 2387 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2388 sponsor_transfer = match collection_mode {2389 CollectionMode::NFT => {2390 2391 2392 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2393 collection_limits.sponsor_transfer_timeout2394 } else {2395 ChainLimit::get().nft_sponsor_transfer_timeout2396 };2397 2398 let mut sponsored = true;2399 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2400 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2401 let limit_time = last_tx_block + limit.into();2402 if block_number <= limit_time {2403 sponsored = false;2404 }2405 }2406 if sponsored {2407 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2408 }24092410 sponsored2411 }2412 CollectionMode::Fungible(_) => {2413 2414 2415 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2416 collection_limits.sponsor_transfer_timeout2417 } else {2418 ChainLimit::get().fungible_sponsor_transfer_timeout2419 };2420 2421 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2422 let mut sponsored = true;2423 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2424 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2425 let limit_time = last_tx_block + limit.into();2426 if block_number <= limit_time {2427 sponsored = false;2428 }2429 }2430 if sponsored {2431 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2432 }24332434 sponsored2435 }2436 CollectionMode::ReFungible => {2437 2438 2439 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2440 collection_limits.sponsor_transfer_timeout2441 } else {2442 ChainLimit::get().refungible_sponsor_transfer_timeout2443 };2444 2445 let mut sponsored = true;2446 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2447 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2448 let limit_time = last_tx_block + limit.into();2449 if block_number <= limit_time {2450 sponsored = false;2451 }2452 }2453 if sponsored {2454 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2455 }24562457 sponsored2458 }2459 _ => {2460 false2461 },2462 };2463 }24642465 if !sponsor_transfer {2466 T::AccountId::default()2467 } else {2468 <Collection<T>>::get(collection_id).sponsor2469 }2470 }24712472 _ => T::AccountId::default(),2473 };24742475 2476 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {24772478 2479 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {24802481 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2482 &who,2483 code_hash,2484 salt,2485 );2486 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());24872488 T::AccountId::default()2489 },24902491 2492 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {24932494 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());24952496 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2497 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2498 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2499 2500 if !owned_contract && white_list_enabled {2501 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2502 return Err(InvalidTransaction::Call.into());2503 }2504 }25052506 let mut sponsor_transfer = false;2507 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2508 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2509 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2510 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2511 let limit_time = last_tx_block + rate_limit;25122513 if block_number >= limit_time {2514 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2515 sponsor_transfer = true;2516 }2517 } else {2518 sponsor_transfer = false;2519 }2520 2521 2522 let mut sp = T::AccountId::default();2523 if sponsor_transfer {2524 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2525 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2526 sp = called_contract;2527 }2528 }2529 }25302531 sp2532 },25332534 _ => sponsor,2535 };25362537 let mut who_pays_fee: T::AccountId = sponsor.clone();2538 if sponsor == T::AccountId::default() {2539 who_pays_fee = who.clone();2540 }25412542 <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2543 .map(|i| (fee, i))2544 }2545}254625472548impl<T: Config + Send + Sync> SignedExtension2549 for ChargeTransactionPayment<T>2550where2551 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2552 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2553 T::AccountId: AsRef<[u8]>,2554 T::AccountId: UncheckedFrom<T::Hash>,2555{2556 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2557 type AccountId = T::AccountId;2558 type Call = T::Call;2559 type AdditionalSigned = ();2560 type Pre = (2561 2562 BalanceOf<T>,2563 2564 Self::AccountId,2565 2566 <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2567 );2568 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2569 Ok(())2570 }25712572 fn validate(2573 &self,2574 who: &Self::AccountId,2575 call: &Self::Call,2576 info: &DispatchInfoOf<Self::Call>,2577 len: usize,2578 ) -> TransactionValidity {2579 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2580 Ok(ValidTransaction {2581 priority: Self::get_priority(len, info, fee),2582 ..Default::default()2583 })2584 }25852586 fn pre_dispatch(2587 self,2588 who: &Self::AccountId,2589 call: &Self::Call,2590 info: &DispatchInfoOf<Self::Call>,2591 len: usize,2592 ) -> Result<Self::Pre, TransactionValidityError> {2593 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2594 Ok((self.0, who.clone(), imbalance))2595 }25962597 fn post_dispatch(2598 pre: Self::Pre,2599 info: &DispatchInfoOf<Self::Call>,2600 post_info: &PostDispatchInfoOf<Self::Call>,2601 len: usize,2602 _result: &DispatchResult,2603 ) -> Result<(), TransactionValidityError> {2604 let (tip, who, imbalance) = pre;2605 let actual_fee = transaction_payment::Module::<T>::compute_actual_fee(2606 len as u32,2607 info,2608 post_info,2609 tip,2610 );2611 <T as transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2612 Ok(())2613 }2614}26152616