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, Clone, PartialEq)]127#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]128pub struct CollectionType<T: Config> {129 pub owner: T::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: T::AccountId, 140 pub sponsor_confirmed: bool, 141 pub limits: CollectionLimits<T::BlockNumber>, 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<BlockNumber: Encode + Decode> {182 pub account_token_ownership_limit: u32,183 pub sponsored_data_size: u32,184 185 186 187 pub sponsored_data_rate_limit: Option<BlockNumber>,188 pub token_limit: u32,189190 191 pub sponsor_transfer_timeout: u32,192 pub owner_can_transfer: bool,193 pub owner_can_destroy: bool,194}195196impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {197 fn default() -> Self {198 Self { 199 account_token_ownership_limit: 10_000_000, 200 token_limit: u32::max_value(),201 sponsored_data_size: u32::max_value(), 202 sponsored_data_rate_limit: None,203 sponsor_transfer_timeout: 14400,204 owner_can_transfer: true,205 owner_can_destroy: true206 }207 }208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct ChainLimits {213 pub collection_numbers_limit: u32,214 pub account_token_ownership_limit: u32,215 pub collections_admins_limit: u64,216 pub custom_data_limit: u32,217218 219 pub nft_sponsor_transfer_timeout: u32,220 pub fungible_sponsor_transfer_timeout: u32,221 pub refungible_sponsor_transfer_timeout: u32,222223 224 pub offchain_schema_limit: u32,225 pub variable_on_chain_schema_limit: u32,226 pub const_on_chain_schema_limit: u32,227}228229pub trait WeightInfo {230 fn create_collection() -> Weight;231 fn destroy_collection() -> Weight;232 fn add_to_white_list() -> Weight;233 fn remove_from_white_list() -> Weight;234 fn set_public_access_mode() -> Weight;235 fn set_mint_permission() -> Weight;236 fn change_collection_owner() -> Weight;237 fn add_collection_admin() -> Weight;238 fn remove_collection_admin() -> Weight;239 fn set_collection_sponsor() -> Weight;240 fn confirm_sponsorship() -> Weight;241 fn remove_collection_sponsor() -> Weight;242 fn create_item(s: usize) -> Weight;243 fn burn_item() -> Weight;244 fn transfer() -> Weight;245 fn approve() -> Weight;246 fn transfer_from() -> Weight;247 fn set_offchain_schema() -> Weight;248 fn set_const_on_chain_schema() -> Weight;249 fn set_variable_on_chain_schema() -> Weight;250 fn set_variable_meta_data() -> Weight;251 fn enable_contract_sponsoring() -> Weight;252 fn set_schema_version() -> Weight;253 fn set_chain_limits() -> Weight;254 fn set_contract_sponsoring_rate_limit() -> Weight;255 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;256 fn toggle_contract_white_list() -> Weight;257 fn add_to_contract_white_list() -> Weight;258 fn remove_from_contract_white_list() -> Weight;259 fn set_collection_limits() -> Weight;260}261262#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]263#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]264pub struct CreateNftData {265 pub const_data: Vec<u8>,266 pub variable_data: Vec<u8>,267}268269#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]270#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]271pub struct CreateFungibleData {272 pub value: u128,273}274275#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]276#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]277pub struct CreateReFungibleData {278 pub const_data: Vec<u8>,279 pub variable_data: Vec<u8>,280 pub pieces: u128,281}282283#[derive(Encode, Decode, Debug, Clone, PartialEq)]284#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]285pub enum CreateItemData {286 NFT(CreateNftData),287 Fungible(CreateFungibleData),288 ReFungible(CreateReFungibleData),289}290291impl CreateItemData {292 pub fn len(&self) -> usize {293 let len = match self {294 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),295 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),296 _ => 0297 };298 299 return len;300 }301}302303impl From<CreateNftData> for CreateItemData {304 fn from(item: CreateNftData) -> Self {305 CreateItemData::NFT(item)306 }307}308309impl From<CreateReFungibleData> for CreateItemData {310 fn from(item: CreateReFungibleData) -> Self {311 CreateItemData::ReFungible(item)312 }313}314315impl From<CreateFungibleData> for CreateItemData {316 fn from(item: CreateFungibleData) -> Self {317 CreateItemData::Fungible(item)318 }319}320321322decl_error! {323 324 pub enum Error for Module<T: Config> {325 326 TotalCollectionsLimitExceeded,327 328 CollectionDecimalPointLimitExceeded, 329 330 CollectionNameLimitExceeded, 331 332 CollectionDescriptionLimitExceeded, 333 334 CollectionTokenPrefixLimitExceeded,335 336 CollectionNotFound,337 338 TokenNotFound,339 340 AdminNotFound,341 342 NumOverflow, 343 344 AlreadyAdmin, 345 346 NoPermission,347 348 ConfirmUnsetSponsorFail,349 350 PublicMintingNotAllowed,351 352 MustBeTokenOwner,353 354 TokenValueTooLow,355 356 NftSizeLimitExceeded,357 358 ApproveNotFound,359 360 TokenValueNotEnough,361 362 ApproveRequired,363 364 AddresNotInWhiteList,365 366 CollectionAdminsLimitExceeded,367 368 AddressOwnershipLimitExceeded,369 370 EmptyArgument,371 372 TokenConstDataLimitExceeded,373 374 TokenVariableDataLimitExceeded,375 376 NotNftDataUsedToMintNftCollectionToken,377 378 NotFungibleDataUsedToMintFungibleCollectionToken,379 380 NotReFungibleDataUsedToMintReFungibleCollectionToken,381 382 UnexpectedCollectionType,383 384 CantStoreMetadataInFungibleTokens,385 386 CollectionTokenLimitExceeded,387 388 AccountTokenLimitExceeded,389 390 CollectionLimitBoundsExceeded,391 392 SchemaDataLimitExceeded,393 394 WrongRefungiblePieces395 }396}397398pub trait Config: system::Config + Sized + transaction_payment::Config + pallet_contracts::Config {399 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;400401 402 type WeightInfo: WeightInfo;403}404405#[cfg(feature = "runtime-benchmarks")]406mod benchmarking;407408409410decl_storage! {411 trait Store for Module<T: Config> as Nft {412413 414 NextCollectionID: CollectionId;415 CreatedCollectionCount: u32;416 ChainVersion: u64;417 ItemListIndex: map hasher(identity) CollectionId => TokenId;418419 420 pub ChainLimit get(fn chain_limit) config(): ChainLimits;421422 423 CollectionCount: u32;424 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;425426 427 pub Collection get(fn collection) config(): map hasher(identity) CollectionId => Option<CollectionType<T>> = None;428 pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;429 pub WhiteList get(fn white_list): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => bool;430431 432 pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;433434 435 pub Allowances get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId, T::AccountId) => u128;436437 438 pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;439 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => FungibleItemType;440 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;441442 443 pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;444445 446 pub CreateItemBasket get(fn create_item_basket): map hasher(twox_64_concat) (CollectionId, T::AccountId) => T::BlockNumber;447 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;448 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;449 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;450451 452 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => Option<T::BlockNumber> = None;453454 455 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;456 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;457 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;458 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;459 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 460 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(twox_64_concat) T::AccountId => bool; 461 }462 add_extra_genesis {463 build(|config: &GenesisConfig<T>| {464 465 for (_num, _c) in &config.collection {466 <Module<T>>::init_collection(_c);467 }468469 for (_num, _c, _i) in &config.nft_item_id {470 <Module<T>>::init_nft_token(*_c, _i);471 }472473 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {474 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);475 }476477 for (_num, _c, _i) in &config.refungible_item_id {478 <Module<T>>::init_refungible_token(*_c, _i);479 }480 })481 }482}483484decl_event!(485 pub enum Event<T>486 where487 AccountId = <T as system::Config>::AccountId,488 {489 490 491 492 493 494 495 496 497 498 Created(CollectionId, u8, AccountId),499500 501 502 503 504 505 506 507 ItemCreated(CollectionId, TokenId),508509 510 511 512 513 514 515 516 ItemDestroyed(CollectionId, TokenId),517 }518);519520decl_module! {521 pub struct Module<T: Config> for enum Call 522 where 523 origin: T::Origin524 {525 fn deposit_event() = default;526 type Error = Error<T>;527528 fn on_initialize(now: T::BlockNumber) -> Weight {529530 if ChainVersion::get() < 2531 {532 let value = NextCollectionID::get();533 CreatedCollectionCount::put(value);534 ChainVersion::put(2);535 }536537 0538 }539540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 #[weight = <T as Config>::WeightInfo::create_collection()]557 pub fn create_collection(origin,558 collection_name: Vec<u16>,559 collection_description: Vec<u16>,560 token_prefix: Vec<u8>,561 mode: CollectionMode) -> DispatchResult {562563 564 let who = ensure_signed(origin)?;565566 let decimal_points = match mode {567 CollectionMode::Fungible(points) => points,568 _ => 0569 };570571 572 ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);573574 575 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);576 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);577 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);578 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);579580 581 let next_id = CreatedCollectionCount::get()582 .checked_add(1)583 .ok_or(Error::<T>::NumOverflow)?;584585 586 let total = CollectionCount::get()587 .checked_add(1)588 .ok_or(Error::<T>::NumOverflow)?;589590 CreatedCollectionCount::put(next_id);591 CollectionCount::put(total);592593 594 let new_collection = CollectionType {595 owner: who.clone(),596 name: collection_name,597 mode: mode.clone(),598 mint_mode: false,599 access: AccessMode::Normal,600 description: collection_description,601 decimal_points: decimal_points,602 token_prefix: token_prefix,603 offchain_schema: Vec::new(),604 schema_version: SchemaVersion::ImageURL,605 sponsor: T::AccountId::default(),606 sponsor_confirmed: false,607 variable_on_chain_schema: Vec::new(),608 const_on_chain_schema: Vec::new(),609 limits: CollectionLimits::default()610 };611612 613 <Collection<T>>::insert(next_id, new_collection);614615 616 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));617618 Ok(())619 }620621 622 623 624 625 626 627 628 629 630 #[weight = <T as Config>::WeightInfo::destroy_collection()]631 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {632633 let sender = ensure_signed(origin)?;634 Self::check_owner_permissions(collection_id, sender)?;635636 <AddressTokens<T>>::remove_prefix(collection_id);637 <Allowances<T>>::remove_prefix(collection_id);638 <Balance<T>>::remove_prefix(collection_id);639 <ItemListIndex>::remove(collection_id);640 <AdminList<T>>::remove(collection_id);641 <Collection<T>>::remove(collection_id);642 <WhiteList<T>>::remove_prefix(collection_id);643644 <NftItemList<T>>::remove_prefix(collection_id);645 <FungibleItemList<T>>::remove_prefix(collection_id);646 <ReFungibleItemList<T>>::remove_prefix(collection_id);647648 <NftTransferBasket<T>>::remove_prefix(collection_id);649 <FungibleTransferBasket<T>>::remove_prefix(collection_id);650 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);651652 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);653654 if CollectionCount::get() > 0655 {656 657 let total = CollectionCount::get()658 .checked_sub(1)659 .ok_or(Error::<T>::NumOverflow)?;660661 CollectionCount::put(total);662 }663664 Ok(())665 }666667 668 669 670 671 672 673 674 675 676 677 678 679 #[weight = <T as Config>::WeightInfo::add_to_white_list()]680 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{681682 let sender = ensure_signed(origin)?;683 Self::check_owner_or_admin_permissions(collection_id, sender)?;684685 <WhiteList<T>>::insert(collection_id, address, true);686 687 Ok(())688 }689690 691 692 693 694 695 696 697 698 699 700 701 702 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]703 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{704705 let sender = ensure_signed(origin)?;706 Self::check_owner_or_admin_permissions(collection_id, sender)?;707708 <WhiteList<T>>::remove(collection_id, address);709710 Ok(())711 }712713 714 715 716 717 718 719 720 721 722 723 724 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]725 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult726 {727 let sender = ensure_signed(origin)?;728729 Self::check_owner_permissions(collection_id, sender)?;730 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();731 target_collection.access = mode;732 <Collection<T>>::insert(collection_id, target_collection);733734 Ok(())735 }736737 738 739 740 741 742 743 744 745 746 747 748 749 750 #[weight = <T as Config>::WeightInfo::set_mint_permission()]751 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult752 {753 let sender = ensure_signed(origin)?;754755 Self::check_owner_permissions(collection_id, sender)?;756 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();757 target_collection.mint_mode = mint_permission;758 <Collection<T>>::insert(collection_id, target_collection);759760 Ok(())761 }762763 764 765 766 767 768 769 770 771 772 773 774 #[weight = <T as Config>::WeightInfo::change_collection_owner()]775 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {776777 let sender = ensure_signed(origin)?;778 Self::check_owner_permissions(collection_id, sender)?;779 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();780 target_collection.owner = new_owner;781 <Collection<T>>::insert(collection_id, target_collection);782783 Ok(())784 }785786 787 788 789 790 791 792 793 794 795 796 797 798 799 #[weight = <T as Config>::WeightInfo::add_collection_admin()]800 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {801802 let sender = ensure_signed(origin)?;803 Self::check_owner_or_admin_permissions(collection_id, sender)?;804 let mut admin_arr: Vec<T::AccountId> = Vec::new();805806 if <AdminList<T>>::contains_key(collection_id)807 {808 admin_arr = <AdminList<T>>::get(collection_id);809 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);810 }811812 813 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);814815 admin_arr.push(new_admin_id);816 <AdminList<T>>::insert(collection_id, admin_arr);817818 Ok(())819 }820821 822 823 824 825 826 827 828 829 830 831 832 833 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]834 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {835836 let sender = ensure_signed(origin)?;837 Self::check_owner_or_admin_permissions(collection_id, sender)?;838 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);839840 let mut admin_arr = <AdminList<T>>::get(collection_id);841 admin_arr.retain(|i| *i != account_id);842 <AdminList<T>>::insert(collection_id, admin_arr);843844 Ok(())845 }846847 848 849 850 851 852 853 854 855 856 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]857 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {858859 let sender = ensure_signed(origin)?;860861 let mut target_collection = <Collection<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?;862 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);863864 target_collection.sponsor = new_sponsor;865 target_collection.sponsor_confirmed = false;866 <Collection<T>>::insert(collection_id, target_collection);867868 Ok(())869 }870871 872 873 874 875 876 877 878 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]879 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {880881 let sender = ensure_signed(origin)?;882883 let mut target_collection = <Collection<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?;884 ensure!(sender == target_collection.sponsor, Error::<T>::ConfirmUnsetSponsorFail);885886 target_collection.sponsor_confirmed = true;887 <Collection<T>>::insert(collection_id, target_collection);888889 Ok(())890 }891892 893 894 895 896 897 898 899 900 901 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]902 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {903904 let sender = ensure_signed(origin)?;905906 let mut target_collection = <Collection<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?;907 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);908909 target_collection.sponsor = T::AccountId::default();910 target_collection.sponsor_confirmed = false;911 <Collection<T>>::insert(collection_id, target_collection);912913 Ok(())914 }915916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939940 #[weight = <T as Config>::WeightInfo::create_item(data.len())]941 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {942943 let sender = ensure_signed(origin)?;944945 Self::collection_exists(collection_id)?;946947 let target_collection = <Collection<T>>::get(collection_id).unwrap();948949 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;950 Self::validate_create_item_args(&target_collection, &data)?;951 Self::create_item_no_validation(collection_id, owner, data)?;952953 Ok(())954 }955956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()975 .map(|data| { data.len() })976 .sum())]977 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {978979 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);980 let sender = ensure_signed(origin)?;981982 Self::collection_exists(collection_id)?;983 let target_collection = <Collection<T>>::get(collection_id).unwrap();984985 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;986987 for data in &items_data {988 Self::validate_create_item_args(&target_collection, data)?;989 }990 for data in &items_data {991 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;992 }993994 Ok(())995 }996997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 #[weight = <T as Config>::WeightInfo::burn_item()]1011 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10121013 let sender = ensure_signed(origin)?;1014 Self::collection_exists(collection_id)?;10151016 1017 let target_collection = <Collection<T>>::get(collection_id).unwrap();1018 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1019 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1020 Error::<T>::NoPermission);10211022 if target_collection.access == AccessMode::WhiteList {1023 Self::check_white_list(collection_id, &sender)?;1024 }10251026 match target_collection.mode1027 {1028 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1029 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1030 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1031 _ => ()1032 };10331034 1035 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10361037 Ok(())1038 }10391040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 #[weight = <T as Config>::WeightInfo::transfer()]1064 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1065 let sender = ensure_signed(origin)?;1066 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1067 }10681069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 #[weight = <T as Config>::WeightInfo::approve()]1085 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {10861087 let sender = ensure_signed(origin)?;10881089 Self::collection_exists(collection_id)?;1090 Self::token_exists(collection_id, item_id, &sender)?;10911092 1093 let target_collection = <Collection<T>>::get(collection_id).unwrap();1094 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1095 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1096 Error::<T>::NoPermission);10971098 if target_collection.access == AccessMode::WhiteList {1099 Self::check_white_list(collection_id, &sender)?;1100 Self::check_white_list(collection_id, &spender)?;1101 }11021103 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1104 let mut allowance: u128 = amount;1105 if allowance_exists {1106 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1107 }1108 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);11091110 Ok(())1111 }1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 #[weight = <T as Config>::WeightInfo::transfer_from()]1133 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11341135 let sender = ensure_signed(origin)?;1136 let mut appoved_transfer = false;11371138 1139 let mut approval: u128 = 0;1140 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1141 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1142 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1143 appoved_transfer = true;1144 }11451146 let target_collection = <Collection<T>>::get(collection_id).unwrap();11471148 1149 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11501151 1152 ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1153 Error::<T>::NoPermission);11541155 if target_collection.access == AccessMode::WhiteList {1156 Self::check_white_list(collection_id, &sender)?;1157 Self::check_white_list(collection_id, &recipient)?;1158 }11591160 1161 if approval.checked_sub(value).unwrap_or(0) > 0 {1162 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1163 }1164 else {1165 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1166 }11671168 match target_collection.mode1169 {1170 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1171 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1172 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1173 _ => ()1174 };11751176 Ok(())1177 }11781179 1180 11811182 1183 1184 1185 11861187 11881189 11901191 1192 11931194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1207 pub fn set_variable_meta_data (1208 origin,1209 collection_id: CollectionId,1210 item_id: TokenId,1211 data: Vec<u8>1212 ) -> DispatchResult {1213 let sender = ensure_signed(origin)?;1214 1215 Self::collection_exists(collection_id)?;1216 Self::token_exists(collection_id, item_id, &sender)?;12171218 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12191220 1221 let target_collection = <Collection<T>>::get(collection_id).unwrap();1222 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1223 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1224 Error::<T>::NoPermission);12251226 match target_collection.mode1227 {1228 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1229 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1230 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1231 _ => fail!(Error::<T>::UnexpectedCollectionType)1232 };12331234 Ok(())1235 }1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 #[weight = <T as Config>::WeightInfo::set_schema_version()]1252 pub fn set_schema_version(1253 origin,1254 collection_id: CollectionId,1255 version: SchemaVersion1256 ) -> DispatchResult {1257 let sender = ensure_signed(origin)?;1258 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1259 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();1260 target_collection.schema_version = version;1261 <Collection<T>>::insert(collection_id, target_collection);12621263 Ok(())1264 }12651266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1279 pub fn set_offchain_schema(1280 origin,1281 collection_id: CollectionId,1282 schema: Vec<u8>1283 ) -> DispatchResult {1284 let sender = ensure_signed(origin)?;1285 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12861287 1288 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");12891290 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();1291 target_collection.offchain_schema = schema;1292 <Collection<T>>::insert(collection_id, target_collection);12931294 Ok(())1295 }12961297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1310 pub fn set_const_on_chain_schema (1311 origin,1312 collection_id: CollectionId,1313 schema: Vec<u8>1314 ) -> DispatchResult {1315 let sender = ensure_signed(origin)?;1316 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13171318 1319 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");13201321 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();1322 target_collection.const_on_chain_schema = schema;1323 <Collection<T>>::insert(collection_id, target_collection);13241325 Ok(())1326 }13271328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1341 pub fn set_variable_on_chain_schema (1342 origin,1343 collection_id: CollectionId,1344 schema: Vec<u8>1345 ) -> DispatchResult {1346 let sender = ensure_signed(origin)?;1347 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13481349 1350 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");13511352 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();1353 target_collection.variable_on_chain_schema = schema;1354 <Collection<T>>::insert(collection_id, target_collection);13551356 Ok(())1357 }13581359 1360 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1361 pub fn set_chain_limits(1362 origin,1363 limits: ChainLimits1364 ) -> DispatchResult {13651366 #[cfg(not(feature = "runtime-benchmarks"))]1367 ensure_root(origin)?;13681369 <ChainLimit>::put(limits);1370 Ok(())1371 }13721373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1385 pub fn enable_contract_sponsoring(1386 origin,1387 contract_address: T::AccountId,1388 enable: bool1389 ) -> DispatchResult {13901391 let sender = ensure_signed(origin)?;13921393 #[cfg(feature = "runtime-benchmarks")]1394 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13951396 Self::ensure_contract_owned(sender, &contract_address)?;13971398 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1399 Ok(())1400 }14011402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1420 pub fn set_contract_sponsoring_rate_limit(1421 origin,1422 contract_address: T::AccountId,1423 rate_limit: T::BlockNumber1424 ) -> DispatchResult {1425 let sender = ensure_signed(origin)?;14261427 #[cfg(feature = "runtime-benchmarks")]1428 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14291430 Self::ensure_contract_owned(sender, &contract_address)?;1431 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1432 Ok(())1433 }14341435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1447 pub fn toggle_contract_white_list(1448 origin,1449 contract_address: T::AccountId,1450 enable: bool1451 ) -> DispatchResult {1452 let sender = ensure_signed(origin)?;14531454 #[cfg(feature = "runtime-benchmarks")]1455 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());14561457 Self::ensure_contract_owned(sender, &contract_address)?;1458 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1459 Ok(())1460 }1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1474 pub fn add_to_contract_white_list(1475 origin,1476 contract_address: T::AccountId,1477 account_address: T::AccountId1478 ) -> DispatchResult {1479 let sender = ensure_signed(origin)?;14801481 #[cfg(feature = "runtime-benchmarks")]1482 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1483 1484 Self::ensure_contract_owned(sender, &contract_address)?; 1485 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1486 Ok(())1487 }14881489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1501 pub fn remove_from_contract_white_list(1502 origin,1503 contract_address: T::AccountId,1504 account_address: T::AccountId1505 ) -> DispatchResult {1506 let sender = ensure_signed(origin)?;15071508 #[cfg(feature = "runtime-benchmarks")]1509 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15101511 Self::ensure_contract_owned(sender, &contract_address)?;1512 <ContractWhiteList<T>>::remove(contract_address, account_address);1513 Ok(())1514 }15151516 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1517 pub fn set_collection_limits(1518 origin,1519 collection_id: u32,1520 limits: CollectionLimits<T::BlockNumber>,1521 ) -> DispatchResult {1522 let sender = ensure_signed(origin)?;1523 Self::check_owner_permissions(collection_id, sender.clone())?;1524 let mut target_collection = <Collection<T>>::get(collection_id).unwrap();1525 let chain_limits = ChainLimit::get();1526 let climits = target_collection.limits;15271528 1529 ensure!(limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1530 limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP, 1531 Error::<T>::CollectionLimitBoundsExceeded);15321533 1534 ensure!(climits.token_limit > limits.token_limit && 1535 limits.token_limit <= chain_limits.account_token_ownership_limit, 1536 Error::<T>::AccountTokenLimitExceeded);15371538 target_collection.limits = limits;1539 <Collection<T>>::insert(collection_id, target_collection);15401541 Ok(())1542 } 1543 }1544}15451546impl<T: Config> Module<T> {15471548 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {15491550 let target_collection = <Collection<T>>::get(collection_id).unwrap();15511552 1553 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;15541555 1556 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1557 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1558 Error::<T>::NoPermission);15591560 if target_collection.access == AccessMode::WhiteList {1561 Self::check_white_list(collection_id, &sender)?;1562 Self::check_white_list(collection_id, &recipient)?;1563 }15641565 match target_collection.mode1566 {1567 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1568 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1569 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1570 _ => ()1571 };15721573 Ok(())1574 }157515761577 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T>, recipient: &T::AccountId) -> DispatchResult {15781579 1580 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1581 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1582 1583 Ok(())1584 }15851586 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {15871588 1589 let total_items: u32 = ItemListIndex::get(collection_id);1590 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1591 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1592 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);15931594 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1595 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1596 Self::check_white_list(collection_id, owner)?;1597 Self::check_white_list(collection_id, sender)?;1598 }15991600 Ok(())1601 }16021603 fn validate_create_item_args(target_collection: &CollectionType<T>, data: &CreateItemData) -> DispatchResult {1604 match target_collection.mode1605 {1606 CollectionMode::NFT => {1607 if let CreateItemData::NFT(data) = data {1608 1609 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1610 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1611 } else {1612 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1613 }1614 },1615 CollectionMode::Fungible(_) => {1616 if let CreateItemData::Fungible(_) = data {1617 } else {1618 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1619 }1620 },1621 CollectionMode::ReFungible => {1622 if let CreateItemData::ReFungible(data) = data {16231624 1625 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1626 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16271628 1629 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1630 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1631 } else {1632 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1633 }1634 },1635 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1636 };16371638 Ok(())1639 }16401641 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1642 match data1643 {1644 CreateItemData::NFT(data) => {1645 let item = NftItemType {1646 owner,1647 const_data: data.const_data,1648 variable_data: data.variable_data1649 };16501651 Self::add_nft_item(collection_id, item)?;1652 },1653 CreateItemData::Fungible(data) => {1654 Self::add_fungible_item(collection_id, &owner, data.value)?;1655 },1656 CreateItemData::ReFungible(data) => {1657 let mut owner_list = Vec::new();1658 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});16591660 let item = ReFungibleItemType {1661 owner: owner_list,1662 const_data: data.const_data,1663 variable_data: data.variable_data1664 };16651666 Self::add_refungible_item(collection_id, item)?;1667 }1668 };16691670 1671 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));16721673 Ok(())1674 }16751676 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {16771678 1679 let mut balance: u128 = 0;1680 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1681 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1682 } 16831684 1685 let item = FungibleItemType {1686 value: balance + value1687 };1688 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);16891690 1691 let new_balance = <Balance<T>>::get(collection_id, owner)1692 .checked_add(value)1693 .ok_or(Error::<T>::NumOverflow)?;1694 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);16951696 Ok(())1697 }16981699 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1700 let current_index = <ItemListIndex>::get(collection_id)1701 .checked_add(1)1702 .ok_or(Error::<T>::NumOverflow)?;1703 let itemcopy = item.clone();17041705 let value = item.owner.first().unwrap().fraction;1706 let owner = item.owner.first().unwrap().owner.clone();17071708 Self::add_token_index(collection_id, current_index, &owner)?;17091710 <ItemListIndex>::insert(collection_id, current_index);1711 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17121713 1714 let new_balance = <Balance<T>>::get(collection_id, &owner)1715 .checked_add(value)1716 .ok_or(Error::<T>::NumOverflow)?;1717 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);17181719 Ok(())1720 }17211722 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1723 let current_index = <ItemListIndex>::get(collection_id)1724 .checked_add(1)1725 .ok_or(Error::<T>::NumOverflow)?;17261727 let item_owner = item.owner.clone();1728 Self::add_token_index(collection_id, current_index, &item.owner)?;17291730 <ItemListIndex>::insert(collection_id, current_index);1731 <NftItemList<T>>::insert(collection_id, current_index, item);17321733 1734 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1735 .checked_add(1)1736 .ok_or(Error::<T>::NumOverflow)?;1737 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);17381739 Ok(())1740 }17411742 fn burn_refungible_item(1743 collection_id: CollectionId,1744 item_id: TokenId,1745 owner: &T::AccountId,1746 ) -> DispatchResult {1747 ensure!(1748 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1749 Error::<T>::TokenNotFound1750 );1751 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1752 let rft_balance = token1753 .owner1754 .iter()1755 .filter(|&i| i.owner == *owner)1756 .next()1757 .unwrap();1758 Self::remove_token_index(collection_id, item_id, owner)?;17591760 1761 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1762 .checked_sub(rft_balance.fraction)1763 .ok_or(Error::<T>::NumOverflow)?;1764 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);17651766 1767 let index = token1768 .owner1769 .iter()1770 .position(|i| i.owner == *owner)1771 .unwrap();1772 token.owner.remove(index);1773 let owner_count = token.owner.len();17741775 1776 if owner_count == 0 {1777 <ReFungibleItemList<T>>::remove(collection_id, item_id);1778 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1779 }1780 else {1781 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1782 }17831784 Ok(())1785 }17861787 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1788 ensure!(1789 <NftItemList<T>>::contains_key(collection_id, item_id),1790 Error::<T>::TokenNotFound1791 );1792 let item = <NftItemList<T>>::get(collection_id, item_id);1793 Self::remove_token_index(collection_id, item_id, &item.owner)?;17941795 1796 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1797 .checked_sub(1)1798 .ok_or(Error::<T>::NumOverflow)?;1799 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1800 <NftItemList<T>>::remove(collection_id, item_id);1801 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18021803 Ok(())1804 }18051806 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1807 ensure!(1808 <FungibleItemList<T>>::contains_key(collection_id, owner),1809 Error::<T>::TokenNotFound1810 );1811 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1812 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18131814 1815 let new_balance = <Balance<T>>::get(collection_id, owner)1816 .checked_sub(value)1817 .ok_or(Error::<T>::NumOverflow)?;1818 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18191820 if balance.value - value > 0 {1821 balance.value -= value;1822 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1823 }1824 else {1825 <FungibleItemList<T>>::remove(collection_id, owner);1826 }18271828 Ok(())1829 }18301831 fn collection_exists(collection_id: CollectionId) -> DispatchResult {1832 ensure!(1833 <Collection<T>>::contains_key(collection_id),1834 Error::<T>::CollectionNotFound1835 );1836 Ok(())1837 }18381839 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1840 Self::collection_exists(collection_id)?;18411842 let target_collection = <Collection<T>>::get(collection_id).unwrap();1843 ensure!(1844 subject == target_collection.owner,1845 Error::<T>::NoPermission1846 );18471848 Ok(())1849 }18501851 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1852 let target_collection = <Collection<T>>::get(collection_id).unwrap();1853 let mut result: bool = subject == target_collection.owner;1854 let exists = <AdminList<T>>::contains_key(collection_id);18551856 if !result & exists {1857 if <AdminList<T>>::get(collection_id).contains(&subject) {1858 result = true1859 }1860 }18611862 result1863 }18641865 fn check_owner_or_admin_permissions(1866 collection_id: CollectionId,1867 subject: T::AccountId,1868 ) -> DispatchResult {1869 Self::collection_exists(collection_id)?;1870 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());18711872 ensure!(1873 result,1874 Error::<T>::NoPermission1875 );1876 Ok(())1877 }18781879 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1880 let target_collection = <Collection<T>>::get(collection_id).unwrap();18811882 match target_collection.mode {1883 CollectionMode::NFT => {1884 <NftItemList<T>>::get(collection_id, item_id).owner == subject1885 }1886 CollectionMode::Fungible(_) => {1887 <FungibleItemList<T>>::contains_key(collection_id, &subject)1888 }1889 CollectionMode::ReFungible => {1890 <ReFungibleItemList<T>>::get(collection_id, item_id)1891 .owner1892 .iter()1893 .any(|i| i.owner == subject)1894 }1895 CollectionMode::Invalid => false,1896 }1897 }18981899 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1900 let mes = Error::<T>::AddresNotInWhiteList;1901 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);19021903 Ok(())1904 }19051906 1907 1908 fn token_exists(1909 collection_id: CollectionId,1910 item_id: TokenId,1911 owner: &T::AccountId1912 ) -> DispatchResult {1913 let target_collection = <Collection<T>>::get(collection_id).unwrap();1914 let exists = match target_collection.mode1915 {1916 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1917 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),1918 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1919 _ => false1920 };19211922 ensure!(exists == true, Error::<T>::TokenNotFound);1923 Ok(())1924 }19251926 fn transfer_fungible(1927 collection_id: CollectionId,1928 value: u128,1929 owner: &T::AccountId,1930 recipient: &T::AccountId,1931 ) -> DispatchResult {1932 Self::token_exists(collection_id, 0, owner)?;19331934 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1935 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19361937 1938 Self::add_fungible_item(collection_id, recipient, value)?;19391940 1941 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);19421943 1944 if balance.value == value {1945 <FungibleItemList<T>>::remove(collection_id, owner);1946 }1947 else {1948 balance.value -= value;1949 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1950 }19511952 Ok(())1953 }19541955 fn transfer_refungible(1956 collection_id: CollectionId,1957 item_id: TokenId,1958 value: u128,1959 owner: T::AccountId,1960 new_owner: T::AccountId,1961 ) -> DispatchResult {1962 Self::token_exists(collection_id, item_id, &owner)?;19631964 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1965 let item = full_item1966 .owner1967 .iter()1968 .filter(|i| i.owner == owner)1969 .next()1970 .ok_or(Error::<T>::NumOverflow)?;1971 let amount = item.fraction;19721973 ensure!(amount >= value, Error::<T>::TokenValueTooLow);19741975 1976 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1977 .checked_sub(value)1978 .ok_or(Error::<T>::NumOverflow)?;1979 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19801981 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())1982 .checked_add(value)1983 .ok_or(Error::<T>::NumOverflow)?;1984 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);19851986 let old_owner = item.owner.clone();1987 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19881989 1990 if amount == value && !new_owner_has_account {1991 1992 1993 let mut new_full_item = full_item.clone();1994 new_full_item1995 .owner1996 .iter_mut()1997 .find(|i| i.owner == owner)1998 .unwrap()1999 .owner = new_owner.clone();2000 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20012002 2003 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2004 } else {2005 let mut new_full_item = full_item.clone();2006 new_full_item2007 .owner2008 .iter_mut()2009 .find(|i| i.owner == owner)2010 .unwrap()2011 .fraction -= value;20122013 2014 if new_owner_has_account {2015 2016 new_full_item2017 .owner2018 .iter_mut()2019 .find(|i| i.owner == new_owner)2020 .unwrap()2021 .fraction += value;2022 } else {2023 2024 new_full_item.owner.push(Ownership {2025 owner: new_owner.clone(),2026 fraction: value,2027 });2028 Self::add_token_index(collection_id, item_id, &new_owner)?;2029 }20302031 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2032 }20332034 Ok(())2035 }20362037 fn transfer_nft(2038 collection_id: CollectionId,2039 item_id: TokenId,2040 sender: T::AccountId,2041 new_owner: T::AccountId,2042 ) -> DispatchResult {2043 Self::token_exists(collection_id, item_id, &sender)?;20442045 let mut item = <NftItemList<T>>::get(collection_id, item_id);20462047 ensure!(2048 sender == item.owner,2049 Error::<T>::MustBeTokenOwner2050 );20512052 2053 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2054 .checked_sub(1)2055 .ok_or(Error::<T>::NumOverflow)?;2056 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);20572058 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2059 .checked_add(1)2060 .ok_or(Error::<T>::NumOverflow)?;2061 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);20622063 2064 let old_owner = item.owner.clone();2065 item.owner = new_owner.clone();2066 <NftItemList<T>>::insert(collection_id, item_id, item);20672068 2069 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;20702071 Ok(())2072 }2073 2074 fn set_re_fungible_variable_data(2075 collection_id: CollectionId,2076 item_id: TokenId,2077 data: Vec<u8>2078 ) -> DispatchResult {2079 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);20802081 item.variable_data = data;20822083 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);20842085 Ok(())2086 }20872088 fn set_nft_variable_data(2089 collection_id: CollectionId,2090 item_id: TokenId,2091 data: Vec<u8>2092 ) -> DispatchResult {2093 let mut item = <NftItemList<T>>::get(collection_id, item_id);2094 2095 item.variable_data = data;20962097 <NftItemList<T>>::insert(collection_id, item_id, item);2098 2099 Ok(())2100 }21012102 fn init_collection(item: &CollectionType<T>) {2103 2104 assert!(2105 item.decimal_points <= MAX_DECIMAL_POINTS,2106 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2107 );2108 assert!(2109 item.name.len() <= 64,2110 "Collection name can not be longer than 63 char"2111 );2112 assert!(2113 item.name.len() <= 256,2114 "Collection description can not be longer than 255 char"2115 );2116 assert!(2117 item.token_prefix.len() <= 16,2118 "Token prefix can not be longer than 15 char"2119 );21202121 2122 let next_id = CreatedCollectionCount::get()2123 .checked_add(1)2124 .unwrap();21252126 CreatedCollectionCount::put(next_id);2127 }21282129 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2130 let current_index = <ItemListIndex>::get(collection_id)2131 .checked_add(1)2132 .unwrap();21332134 let item_owner = item.owner.clone();2135 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();21362137 <ItemListIndex>::insert(collection_id, current_index);21382139 2140 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2141 .checked_add(1)2142 .unwrap();2143 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2144 }21452146 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2147 let current_index = <ItemListIndex>::get(collection_id)2148 .checked_add(1)2149 .unwrap();21502151 Self::add_token_index(collection_id, current_index, owner).unwrap();21522153 <ItemListIndex>::insert(collection_id, current_index);21542155 2156 let new_balance = <Balance<T>>::get(collection_id, owner)2157 .checked_add(item.value)2158 .unwrap();2159 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2160 }21612162 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2163 let current_index = <ItemListIndex>::get(collection_id)2164 .checked_add(1)2165 .unwrap();21662167 let value = item.owner.first().unwrap().fraction;2168 let owner = item.owner.first().unwrap().owner.clone();21692170 Self::add_token_index(collection_id, current_index, &owner).unwrap();21712172 <ItemListIndex>::insert(collection_id, current_index);21732174 2175 let new_balance = <Balance<T>>::get(collection_id, &owner)2176 .checked_add(value)2177 .unwrap();2178 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2179 }21802181 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {21822183 2184 if <AccountItemCount<T>>::contains_key(owner) {21852186 2187 let count = <AccountItemCount<T>>::get(owner);2188 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);21892190 <AccountItemCount<T>>::insert(owner.clone(), count2191 .checked_add(1)2192 .ok_or(Error::<T>::NumOverflow)?);2193 }2194 else {2195 <AccountItemCount<T>>::insert(owner.clone(), 1);2196 }21972198 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2199 if list_exists {2200 let mut list = <AddressTokens<T>>::get(collection_id, owner);2201 let item_contains = list.contains(&item_index.clone());22022203 if !item_contains {2204 list.push(item_index.clone());2205 }22062207 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2208 } else {2209 let mut itm = Vec::new();2210 itm.push(item_index.clone());2211 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2212 }22132214 Ok(())2215 }22162217 fn remove_token_index(2218 collection_id: CollectionId,2219 item_index: TokenId,2220 owner: &T::AccountId,2221 ) -> DispatchResult {22222223 2224 <AccountItemCount<T>>::insert(owner.clone(), 2225 <AccountItemCount<T>>::get(owner)2226 .checked_sub(1)2227 .ok_or(Error::<T>::NumOverflow)?);222822292230 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2231 if list_exists {2232 let mut list = <AddressTokens<T>>::get(collection_id, owner);2233 let item_contains = list.contains(&item_index.clone());22342235 if item_contains {2236 list.retain(|&item| item != item_index);2237 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2238 }2239 }22402241 Ok(())2242 }22432244 fn move_token_index(2245 collection_id: CollectionId,2246 item_index: TokenId,2247 old_owner: &T::AccountId,2248 new_owner: &T::AccountId,2249 ) -> DispatchResult {2250 Self::remove_token_index(collection_id, item_index, old_owner)?;2251 Self::add_token_index(collection_id, item_index, new_owner)?;22522253 Ok(())2254 }2255 2256 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2257 if <ContractOwner<T>>::contains_key(contract.clone()) {2258 let owner = <ContractOwner<T>>::get(contract);2259 ensure!(account == owner, Error::<T>::NoPermission);2260 } else {2261 fail!(Error::<T>::NoPermission);2262 }22632264 Ok(())2265 }2266}2267226822692270227122722273pub type Multiplier = FixedU128;22742275type BalanceOf<T> = <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::Balance;2276227722782279#[derive(Encode, Decode, Clone, Eq, PartialEq)]2280pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);22812282impl<T: Config + Send + Sync> sp_std::fmt::Debug 2283 for ChargeTransactionPayment<T>2284{2285 #[cfg(feature = "std")]2286 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2287 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2288 }2289 #[cfg(not(feature = "std"))]2290 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2291 Ok(())2292 }2293}22942295impl<T: Config> ChargeTransactionPayment<T>2296where2297 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2298 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2299 T::AccountId: AsRef<[u8]>,2300 T::AccountId: UncheckedFrom<T::Hash>,2301{2302 fn traditional_fee(2303 len: usize,2304 info: &DispatchInfoOf<T::Call>,2305 tip: BalanceOf<T>,2306 ) -> BalanceOf<T>2307 where2308 T::Call: Dispatchable<Info = DispatchInfo>,2309 {2310 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2311 }23122313 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2314 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2315 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2316 let len_saturation = max_block_length as u64 / (len as u64).max(1);2317 let coefficient: BalanceOf<T> = weight_saturation2318 .min(len_saturation)2319 .saturated_into::<BalanceOf<T>>();2320 final_fee2321 .saturating_mul(coefficient)2322 .saturated_into::<TransactionPriority>()2323 }23242325 fn withdraw_fee(2326 &self,2327 who: &T::AccountId,2328 call: &T::Call,2329 info: &DispatchInfoOf<T::Call>,2330 len: usize,2331 ) -> Result<2332 (2333 BalanceOf<T>,2334 <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2335 ),2336 TransactionValidityError,2337 > {2338 let tip = self.0;23392340 2341 2342 2343 2344 2345 2346 2347 let fee = Self::traditional_fee(len, info, tip);23482349 2350 if fee.is_zero() {2351 return <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2352 .map(|i| (fee, i));2353 }23542355 2356 2357 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2358 Some(Call::create_item(collection_id, _owner, _properties)) => {2359 let collection = <Collection<T>>::get(collection_id).unwrap();23602361 2362 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;23632364 let limit = collection.limits.sponsor_transfer_timeout;2365 let mut sponsored = true;2366 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2367 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2368 let limit_time = last_tx_block + limit.into();2369 if block_number <= limit_time {2370 sponsored = false;2371 }2372 }2373 if sponsored {2374 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2375 }23762377 2378 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2379 (collection.sponsor_confirmed) &&2380 (sponsored)2381 {2382 collection.sponsor2383 } else {2384 T::AccountId::default()2385 }2386 }2387 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2388 let collection = <Collection<T>>::get(collection_id).unwrap();2389 2390 let mut sponsor_transfer = false;2391 if collection.sponsor_confirmed {23922393 let collection_limits = collection.limits;2394 let collection_mode = collection.mode;2395 2396 2397 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2398 sponsor_transfer = match collection_mode {2399 CollectionMode::NFT => {2400 2401 2402 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2403 collection_limits.sponsor_transfer_timeout2404 } else {2405 ChainLimit::get().nft_sponsor_transfer_timeout2406 };2407 2408 let mut sponsored = true;2409 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2410 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2411 let limit_time = last_tx_block + limit.into();2412 if block_number <= limit_time {2413 sponsored = false;2414 }2415 }2416 if sponsored {2417 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2418 }24192420 sponsored2421 }2422 CollectionMode::Fungible(_) => {2423 2424 2425 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2426 collection_limits.sponsor_transfer_timeout2427 } else {2428 ChainLimit::get().fungible_sponsor_transfer_timeout2429 };2430 2431 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2432 let mut sponsored = true;2433 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2434 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2435 let limit_time = last_tx_block + limit.into();2436 if block_number <= limit_time {2437 sponsored = false;2438 }2439 }2440 if sponsored {2441 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2442 }24432444 sponsored2445 }2446 CollectionMode::ReFungible => {2447 2448 2449 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2450 collection_limits.sponsor_transfer_timeout2451 } else {2452 ChainLimit::get().refungible_sponsor_transfer_timeout2453 };2454 2455 let mut sponsored = true;2456 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2457 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2458 let limit_time = last_tx_block + limit.into();2459 if block_number <= limit_time {2460 sponsored = false;2461 }2462 }2463 if sponsored {2464 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2465 }24662467 sponsored2468 }2469 _ => {2470 false2471 },2472 };2473 }24742475 if !sponsor_transfer {2476 T::AccountId::default()2477 } else {2478 collection.sponsor2479 }2480 }24812482 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2483 let mut sponsor_metadata_changes = false;24842485 let collection = <Collection<T>>::get(collection_id).unwrap();24862487 if2488 collection.sponsor_confirmed &&2489 2490 2491 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2492 data.len() <= collection.limits.sponsored_data_size as usize2493 {2494 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2495 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;24962497 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2498 .map(|last_block| block_number - last_block > rate_limit)2499 .unwrap_or(true) 2500 {2501 sponsor_metadata_changes = true;2502 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2503 }2504 }2505 }25062507 if !sponsor_metadata_changes {2508 T::AccountId::default()2509 } else {2510 collection.sponsor2511 }2512 }25132514 _ => T::AccountId::default(),2515 };25162517 2518 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {25192520 2521 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {25222523 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2524 &who,2525 code_hash,2526 salt,2527 );2528 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());25292530 T::AccountId::default()2531 },25322533 2534 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {25352536 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());25372538 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2539 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2540 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2541 2542 if !owned_contract && white_list_enabled {2543 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2544 return Err(InvalidTransaction::Call.into());2545 }2546 }25472548 let mut sponsor_transfer = false;2549 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2550 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2551 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2552 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2553 let limit_time = last_tx_block + rate_limit;25542555 if block_number >= limit_time {2556 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2557 sponsor_transfer = true;2558 }2559 } else {2560 sponsor_transfer = false;2561 }2562 2563 2564 let mut sp = T::AccountId::default();2565 if sponsor_transfer {2566 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2567 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2568 sp = called_contract;2569 }2570 }2571 }25722573 sp2574 },25752576 _ => sponsor,2577 };25782579 let mut who_pays_fee: T::AccountId = sponsor.clone();2580 if sponsor == T::AccountId::default() {2581 who_pays_fee = who.clone();2582 }25832584 <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2585 .map(|i| (fee, i))2586 }2587}258825892590impl<T: Config + Send + Sync> SignedExtension2591 for ChargeTransactionPayment<T>2592where2593 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2594 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2595 T::AccountId: AsRef<[u8]>,2596 T::AccountId: UncheckedFrom<T::Hash>,2597{2598 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2599 type AccountId = T::AccountId;2600 type Call = T::Call;2601 type AdditionalSigned = ();2602 type Pre = (2603 2604 BalanceOf<T>,2605 2606 Self::AccountId,2607 2608 <<T as transaction_payment::Config>::OnChargeTransaction as transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2609 );2610 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2611 Ok(())2612 }26132614 fn validate(2615 &self,2616 who: &Self::AccountId,2617 call: &Self::Call,2618 info: &DispatchInfoOf<Self::Call>,2619 len: usize,2620 ) -> TransactionValidity {2621 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2622 Ok(ValidTransaction {2623 priority: Self::get_priority(len, info, fee),2624 ..Default::default()2625 })2626 }26272628 fn pre_dispatch(2629 self,2630 who: &Self::AccountId,2631 call: &Self::Call,2632 info: &DispatchInfoOf<Self::Call>,2633 len: usize,2634 ) -> Result<Self::Pre, TransactionValidityError> {2635 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2636 Ok((self.0, who.clone(), imbalance))2637 }26382639 fn post_dispatch(2640 pre: Self::Pre,2641 info: &DispatchInfoOf<Self::Call>,2642 post_info: &PostDispatchInfoOf<Self::Call>,2643 len: usize,2644 _result: &DispatchResult,2645 ) -> Result<(), TransactionValidityError> {2646 let (tip, who, imbalance) = pre;2647 let actual_fee = transaction_payment::Module::<T>::compute_actual_fee(2648 len as u32,2649 info,2650 post_info,2651 tip,2652 );2653 <T as transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2654 Ok(())2655 }2656}26572658