123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue,32 transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38 traits::{39 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40 },41 transaction_validity::{42 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43 },44 FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263646566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73 Invalid,74 NFT,75 76 Fungible(DecimalPoints),77 ReFungible,78}7980impl Default for CollectionMode {81 fn default() -> Self {82 Self::Invalid83 }84}8586impl Into<u8> for CollectionMode {87 fn into(self) -> u8 {88 match self {89 CollectionMode::Invalid => 0,90 CollectionMode::NFT => 1,91 CollectionMode::Fungible(_) => 2,92 CollectionMode::ReFungible => 3,93 }94 }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100 Normal,101 WhiteList,102}103impl Default for AccessMode {104 fn default() -> Self {105 Self::Normal106 }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112 ImageURL,113 Unique,114}115impl Default for SchemaVersion {116 fn default() -> Self {117 Self::ImageURL118 }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124 pub owner: AccountId,125 pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131 132 Disabled,133 Unconfirmed(AccountId),134 135 Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139 fn sponsor(&self) -> Option<&AccountId> {140 match self {141 Self::Confirmed(sponsor) => Some(sponsor),142 _ => None,143 }144 }145146 fn pending_sponsor(&self) -> Option<&AccountId> {147 match self {148 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149 _ => None,150 }151 }152153 fn confirmed(&self) -> bool {154 matches!(self, Self::Confirmed(_))155 }156}157158impl<T> Default for SponsorshipState<T> {159 fn default() -> Self {160 Self::Disabled161 }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167 pub owner: T::AccountId,168 pub mode: CollectionMode,169 pub access: AccessMode,170 pub decimal_points: DecimalPoints,171 pub name: Vec<u16>, 172 pub description: Vec<u16>, 173 pub token_prefix: Vec<u8>, 174 pub mint_mode: bool,175 pub offchain_schema: Vec<u8>,176 pub schema_version: SchemaVersion,177 pub sponsorship: SponsorshipState<T::AccountId>,178 pub limits: CollectionLimits<T::BlockNumber>, 179 pub variable_on_chain_schema: Vec<u8>, 180 pub const_on_chain_schema: Vec<u8>, 181}182183pub struct CollectionHandle<T: Config> {184 pub id: CollectionId,185 collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189 type Target = Collection<T>;190191 fn deref(&self) -> &Self::Target {192 &self.collection193 }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197 fn deref_mut(&mut self) -> &mut Self::Target {198 &mut self.collection199 }200}201202#[derive(Encode, Decode, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205 pub owner: AccountId,206 pub const_data: Vec<u8>,207 pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213 pub value: u128,214}215216#[derive(Encode, Decode, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219 pub owner: Vec<Ownership<AccountId>>,220 pub const_data: Vec<u8>,221 pub variable_data: Vec<u8>,222}223224225226227228229230231232233234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238 pub account_token_ownership_limit: u32,239 pub sponsored_data_size: u32,240 241 242 243 pub sponsored_data_rate_limit: Option<BlockNumber>,244 pub token_limit: u32,245246 247 pub sponsor_transfer_timeout: u32,248 pub owner_can_transfer: bool,249 pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253 fn default() -> Self {254 Self { 255 account_token_ownership_limit: 10_000_000, 256 token_limit: u32::max_value(),257 sponsored_data_size: u32::MAX, 258 sponsored_data_rate_limit: None,259 sponsor_transfer_timeout: 14400,260 owner_can_transfer: true,261 owner_can_destroy: true262 }263 }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269 pub collection_numbers_limit: u32,270 pub account_token_ownership_limit: u32,271 pub collections_admins_limit: u64,272 pub custom_data_limit: u32,273274 275 pub nft_sponsor_transfer_timeout: u32,276 pub fungible_sponsor_transfer_timeout: u32,277 pub refungible_sponsor_transfer_timeout: u32,278279 280 pub offchain_schema_limit: u32,281 pub variable_on_chain_schema_limit: u32,282 pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286 fn create_collection() -> Weight;287 fn destroy_collection() -> Weight;288 fn add_to_white_list() -> Weight;289 fn remove_from_white_list() -> Weight;290 fn set_public_access_mode() -> Weight;291 fn set_mint_permission() -> Weight;292 fn change_collection_owner() -> Weight;293 fn add_collection_admin() -> Weight;294 fn remove_collection_admin() -> Weight;295 fn set_collection_sponsor() -> Weight;296 fn confirm_sponsorship() -> Weight;297 fn remove_collection_sponsor() -> Weight;298 fn create_item(s: usize) -> Weight;299 fn burn_item() -> Weight;300 fn transfer() -> Weight;301 fn approve() -> Weight;302 fn transfer_from() -> Weight;303 fn set_offchain_schema() -> Weight;304 fn set_const_on_chain_schema() -> Weight;305 fn set_variable_on_chain_schema() -> Weight;306 fn set_variable_meta_data() -> Weight;307 fn enable_contract_sponsoring() -> Weight;308 fn set_schema_version() -> Weight;309 fn set_chain_limits() -> Weight;310 fn set_contract_sponsoring_rate_limit() -> Weight;311 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312 fn toggle_contract_white_list() -> Weight;313 fn add_to_contract_white_list() -> Weight;314 fn remove_from_contract_white_list() -> Weight;315 fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321 pub const_data: Vec<u8>,322 pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328 pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334 pub const_data: Vec<u8>,335 pub variable_data: Vec<u8>,336 pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342 NFT(CreateNftData),343 Fungible(CreateFungibleData),344 ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348 pub fn len(&self) -> usize {349 let len = match self {350 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352 _ => 0353 };354 355 return len;356 }357}358359impl From<CreateNftData> for CreateItemData {360 fn from(item: CreateNftData) -> Self {361 CreateItemData::NFT(item)362 }363}364365impl From<CreateReFungibleData> for CreateItemData {366 fn from(item: CreateReFungibleData) -> Self {367 CreateItemData::ReFungible(item)368 }369}370371impl From<CreateFungibleData> for CreateItemData {372 fn from(item: CreateFungibleData) -> Self {373 CreateItemData::Fungible(item)374 }375}376377378decl_error! {379 380 pub enum Error for Module<T: Config> {381 382 TotalCollectionsLimitExceeded,383 384 CollectionDecimalPointLimitExceeded, 385 386 CollectionNameLimitExceeded, 387 388 CollectionDescriptionLimitExceeded, 389 390 CollectionTokenPrefixLimitExceeded,391 392 CollectionNotFound,393 394 TokenNotFound,395 396 AdminNotFound,397 398 NumOverflow, 399 400 AlreadyAdmin, 401 402 NoPermission,403 404 ConfirmUnsetSponsorFail,405 406 PublicMintingNotAllowed,407 408 MustBeTokenOwner,409 410 TokenValueTooLow,411 412 NftSizeLimitExceeded,413 414 ApproveNotFound,415 416 TokenValueNotEnough,417 418 ApproveRequired,419 420 AddresNotInWhiteList,421 422 CollectionAdminsLimitExceeded,423 424 AddressOwnershipLimitExceeded,425 426 EmptyArgument,427 428 TokenConstDataLimitExceeded,429 430 TokenVariableDataLimitExceeded,431 432 NotNftDataUsedToMintNftCollectionToken,433 434 NotFungibleDataUsedToMintFungibleCollectionToken,435 436 NotReFungibleDataUsedToMintReFungibleCollectionToken,437 438 UnexpectedCollectionType,439 440 CantStoreMetadataInFungibleTokens,441 442 CollectionTokenLimitExceeded,443 444 AccountTokenLimitExceeded,445 446 CollectionLimitBoundsExceeded,447 448 OwnerPermissionsCantBeReverted,449 450 SchemaDataLimitExceeded,451 452 WrongRefungiblePieces,453 454 BadCreateRefungibleCall,455 }456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461 462 type WeightInfo: WeightInfo;463464 type Currency: Currency<Self::AccountId>;465 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466 type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472473474475476477478479480481482483484485486487488489490491492493494495496decl_storage! {497 trait Store for Module<T: Config> as Nft {498499 500 501 CreatedCollectionCount: u32;502 503 ChainVersion: u64;504 505 506 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507 508509 510 pub ChainLimit get(fn chain_limit) config(): ChainLimits;511 512513 514 515 516 DestroyedCollectionCount: u32;517 518 519 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520 521522 523 524 525 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526 527 528 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529 530 531 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532 533534 535 536 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538 539 540 541 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543 544 545 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546 547 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548 549 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550 551552 553 554 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555 556557 558 559 560 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561 562 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563 564 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565 566 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567 568569 570 571 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572 573 574 575 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576 577 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578 579 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580 581 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582 583 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584 585 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586 587 }588 add_extra_genesis {589 build(|config: &GenesisConfig<T>| {590 591 for (_num, _c) in &config.collection_id {592 <Module<T>>::init_collection(_c);593 }594595 for (_num, _c, _i) in &config.nft_item_id {596 <Module<T>>::init_nft_token(*_c, _i);597 }598599 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601 }602603 for (_num, _c, _i) in &config.refungible_item_id {604 <Module<T>>::init_refungible_token(*_c, _i);605 }606 })607 }608}609610decl_event!(611 pub enum Event<T>612 where613 AccountId = <T as system::Config>::AccountId,614 {615 616 617 618 619 620 621 622 623 624 CollectionCreated(CollectionId, u8, AccountId),625626 627 628 629 630 631 632 633 634 635 ItemCreated(CollectionId, TokenId, AccountId),636637 638 639 640 641 642 643 644 ItemDestroyed(CollectionId, TokenId),645646 647 648 649 650 651 652 653 654 655 656 657 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659 660 661 662 663 664 665 666 667 668 Approved(CollectionId, TokenId, AccountId, AccountId, u128),669 }670);671672decl_module! {673 pub struct Module<T: Config> for enum Call 674 where 675 origin: T::Origin676 {677 fn deposit_event() = default;678 type Error = Error<T>;679680 fn on_initialize(now: T::BlockNumber) -> Weight {681 0682 }683684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 #[weight = <T as Config>::WeightInfo::create_collection()]701 #[transactional]702 pub fn create_collection(origin,703 collection_name: Vec<u16>,704 collection_description: Vec<u16>,705 token_prefix: Vec<u8>,706 mode: CollectionMode) -> DispatchResult {707708 709 let who = ensure_signed(origin)?;710711 712 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714 &T::TreasuryAccountId::get(),715 T::CollectionCreationPrice::get(),716 ));717 <T as Config>::Currency::settle(718 &who,719 imbalance,720 WithdrawReasons::TRANSFER,721 ExistenceRequirement::KeepAlive,722 ).map_err(|_| Error::<T>::NoPermission)?;723724 let decimal_points = match mode {725 CollectionMode::Fungible(points) => points,726 _ => 0727 };728729 let chain_limit = ChainLimit::get();730731 let created_count = CreatedCollectionCount::get();732 let destroyed_count = DestroyedCollectionCount::get();733734 735 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737 738 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743 744 let next_id = created_count745 .checked_add(1)746 .ok_or(Error::<T>::NumOverflow)?;747748 CreatedCollectionCount::put(next_id);749750 let limits = CollectionLimits {751 sponsored_data_size: chain_limit.custom_data_limit,752 ..Default::default()753 };754755 756 let new_collection = Collection {757 owner: who.clone(),758 name: collection_name,759 mode: mode.clone(),760 mint_mode: false,761 access: AccessMode::Normal,762 description: collection_description,763 decimal_points: decimal_points,764 token_prefix: token_prefix,765 offchain_schema: Vec::new(),766 schema_version: SchemaVersion::ImageURL,767 sponsorship: SponsorshipState::Disabled,768 variable_on_chain_schema: Vec::new(),769 const_on_chain_schema: Vec::new(),770 limits,771 };772773 774 <CollectionById<T>>::insert(next_id, new_collection);775776 777 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));778779 Ok(())780 }781782 783 784 785 786 787 788 789 790 791 #[weight = <T as Config>::WeightInfo::destroy_collection()]792 #[transactional]793 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795 let sender = ensure_signed(origin)?;796 let collection = Self::get_collection(collection_id)?;797 Self::check_owner_permissions(&collection, sender)?;798 if !collection.limits.owner_can_destroy {799 fail!(Error::<T>::NoPermission);800 }801802 <AddressTokens<T>>::remove_prefix(collection_id);803 <Allowances<T>>::remove_prefix(collection_id);804 <Balance<T>>::remove_prefix(collection_id);805 <ItemListIndex>::remove(collection_id);806 <AdminList<T>>::remove(collection_id);807 <CollectionById<T>>::remove(collection_id);808 <WhiteList<T>>::remove_prefix(collection_id);809810 <NftItemList<T>>::remove_prefix(collection_id);811 <FungibleItemList<T>>::remove_prefix(collection_id);812 <ReFungibleItemList<T>>::remove_prefix(collection_id);813814 <NftTransferBasket<T>>::remove_prefix(collection_id);815 <FungibleTransferBasket<T>>::remove_prefix(collection_id);816 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820 DestroyedCollectionCount::put(DestroyedCollectionCount::get()821 .checked_add(1)822 .ok_or(Error::<T>::NumOverflow)?);823824 Ok(())825 }826827 828 829 830 831 832 833 834 835 836 837 838 839 #[weight = <T as Config>::WeightInfo::add_to_white_list()]840 #[transactional]841 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843 let sender = ensure_signed(origin)?;844 let collection = Self::get_collection(collection_id)?;845 Self::check_owner_or_admin_permissions(&collection, sender)?;846847 <WhiteList<T>>::insert(collection_id, address, true);848 849 Ok(())850 }851852 853 854 855 856 857 858 859 860 861 862 863 864 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]865 #[transactional]866 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{867868 let sender = ensure_signed(origin)?;869 let collection = Self::get_collection(collection_id)?;870 Self::check_owner_or_admin_permissions(&collection, sender)?;871872 <WhiteList<T>>::remove(collection_id, address);873874 Ok(())875 }876877 878 879 880 881 882 883 884 885 886 887 888 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]889 #[transactional]890 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult891 {892 let sender = ensure_signed(origin)?;893894 let mut target_collection = Self::get_collection(collection_id)?;895 Self::check_owner_permissions(&target_collection, sender)?;896 target_collection.access = mode;897 Self::save_collection(target_collection);898899 Ok(())900 }901902 903 904 905 906 907 908 909 910 911 912 913 914 915 #[weight = <T as Config>::WeightInfo::set_mint_permission()]916 #[transactional]917 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult918 {919 let sender = ensure_signed(origin)?;920921 let mut target_collection = Self::get_collection(collection_id)?;922 Self::check_owner_permissions(&target_collection, sender)?;923 target_collection.mint_mode = mint_permission;924 Self::save_collection(target_collection);925926 Ok(())927 }928929 930 931 932 933 934 935 936 937 938 939 940 #[weight = <T as Config>::WeightInfo::change_collection_owner()]941 #[transactional]942 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {943944 let sender = ensure_signed(origin)?;945 let mut target_collection = Self::get_collection(collection_id)?;946 Self::check_owner_permissions(&target_collection, sender)?;947 target_collection.owner = new_owner;948 Self::save_collection(target_collection);949950 Ok(())951 }952953 954 955 956 957 958 959 960 961 962 963 964 965 966 #[weight = <T as Config>::WeightInfo::add_collection_admin()]967 #[transactional]968 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {969970 let sender = ensure_signed(origin)?;971 let collection = Self::get_collection(collection_id)?;972 Self::check_owner_or_admin_permissions(&collection, sender)?;973 let mut admin_arr = <AdminList<T>>::get(collection_id);974975 match admin_arr.binary_search(&new_admin_id) {976 Ok(_) => {},977 Err(idx) => {978 let limits = ChainLimit::get();979 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);980 admin_arr.insert(idx, new_admin_id);981 <AdminList<T>>::insert(collection_id, admin_arr);982 }983 }984 Ok(())985 }986987 988 989 990 991 992 993 994 995 996 997 998 999 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1000 #[transactional]1001 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10021003 let sender = ensure_signed(origin)?;1004 let collection = Self::get_collection(collection_id)?;1005 Self::check_owner_or_admin_permissions(&collection, sender)?;1006 let mut admin_arr = <AdminList<T>>::get(collection_id);10071008 match admin_arr.binary_search(&account_id) {1009 Ok(idx) => {1010 admin_arr.remove(idx);1011 <AdminList<T>>::insert(collection_id, admin_arr);1012 },1013 Err(_) => {}1014 }1015 Ok(())1016 }10171018 1019 1020 1021 1022 1023 1024 1025 1026 1027 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1028 #[transactional]1029 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10301031 let sender = ensure_signed(origin)?;1032 let mut target_collection = Self::get_collection(collection_id)?;1033 Self::check_owner_permissions(&target_collection, sender)?;10341035 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1036 Self::save_collection(target_collection);10371038 Ok(())1039 }10401041 1042 1043 1044 1045 1046 1047 1048 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1049 #[transactional]1050 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10511052 let sender = ensure_signed(origin)?;10531054 let mut target_collection = Self::get_collection(collection_id)?;1055 ensure!(1056 target_collection.sponsorship.pending_sponsor() == Some(&sender),1057 Error::<T>::ConfirmUnsetSponsorFail1058 );10591060 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1061 Self::save_collection(target_collection);10621063 Ok(())1064 }10651066 1067 1068 1069 1070 1071 1072 1073 1074 1075 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1076 #[transactional]1077 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10781079 let sender = ensure_signed(origin)?;10801081 let mut target_collection = Self::get_collection(collection_id)?;1082 Self::check_owner_permissions(&target_collection, sender)?;10831084 target_collection.sponsorship = SponsorshipState::Disabled;1085 Self::save_collection(target_collection);10861087 Ok(())1088 }10891090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 11131114 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1115 #[transactional]1116 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1117 let sender = ensure_signed(origin)?;1118 Self::create_item_internal(sender, collection_id, owner, data)1119 }11201121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1140 .map(|data| { data.len() })1141 .sum())]1142 #[transactional]1143 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11441145 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1146 let sender = ensure_signed(origin)?;11471148 let target_collection = Self::get_collection(collection_id)?;11491150 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11511152 for data in &items_data {1153 Self::validate_create_item_args(&target_collection, data)?;1154 }1155 for data in &items_data {1156 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1157 }11581159 Ok(())1160 }11611162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 #[weight = <T as Config>::WeightInfo::burn_item()]1176 #[transactional]1177 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11781179 let sender = ensure_signed(origin)?;11801181 1182 let target_collection = Self::get_collection(collection_id)?;1183 ensure!(1184 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1185 (1186 target_collection.limits.owner_can_transfer &&1187 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1188 ),1189 Error::<T>::NoPermission1190 );11911192 if target_collection.access == AccessMode::WhiteList {1193 Self::check_white_list(&target_collection, &sender)?;1194 }11951196 match target_collection.mode1197 {1198 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1199 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1200 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1201 _ => ()1202 };12031204 1205 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12061207 Ok(())1208 }12091210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 #[weight = <T as Config>::WeightInfo::transfer()]1234 #[transactional]1235 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1236 let sender = ensure_signed(origin)?;1237 let collection = Self::get_collection(collection_id)?;12381239 Self::transfer_internal(sender, recipient, &collection, item_id, value)1240 }12411242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 #[weight = <T as Config>::WeightInfo::approve()]1258 #[transactional]1259 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12601261 let sender = ensure_signed(origin)?;1262 let target_collection = Self::get_collection(collection_id)?;12631264 Self::token_exists(&target_collection, item_id)?;12651266 1267 let bypasses_limits = target_collection.limits.owner_can_transfer &&1268 Self::is_owner_or_admin_permissions(1269 &target_collection,1270 sender.clone(),1271 );12721273 let allowance_limit = if bypasses_limits {1274 None1275 } else if let Some(amount) = Self::owned_amount(1276 sender.clone(),1277 &target_collection,1278 item_id,1279 ) {1280 Some(amount)1281 } else {1282 fail!(Error::<T>::NoPermission);1283 };12841285 if target_collection.access == AccessMode::WhiteList {1286 Self::check_white_list(&target_collection, &sender)?;1287 Self::check_white_list(&target_collection, &spender)?;1288 }12891290 let allowance: u128 = amount1291 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1292 .ok_or(Error::<T>::NumOverflow)?;1293 if let Some(limit) = allowance_limit {1294 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1295 }1296 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12971298 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1299 Ok(())1300 }1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 #[weight = <T as Config>::WeightInfo::transfer_from()]1322 #[transactional]1323 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13241325 let sender = ensure_signed(origin)?;1326 let target_collection = Self::get_collection(collection_id)?;13271328 1329 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13301331 1332 Self::is_correct_transfer(&target_collection, &recipient)?;13331334 1335 ensure!(1336 approval >= value || 1337 (1338 target_collection.limits.owner_can_transfer &&1339 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1340 ),1341 Error::<T>::NoPermission1342 );13431344 if target_collection.access == AccessMode::WhiteList {1345 Self::check_white_list(&target_collection, &sender)?;1346 Self::check_white_list(&target_collection, &recipient)?;1347 }13481349 1350 if approval.saturating_sub(value) > 0 {1351 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1352 }1353 else {1354 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1355 }13561357 match target_collection.mode1358 {1359 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1360 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1361 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1362 _ => ()1363 };13641365 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1366 Ok(())1367 }13681369 1370 13711372 1373 1374 1375 13761377 13781379 13801381 1382 13831384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1397 #[transactional]1398 pub fn set_variable_meta_data (1399 origin,1400 collection_id: CollectionId,1401 item_id: TokenId,1402 data: Vec<u8>1403 ) -> DispatchResult {1404 let sender = ensure_signed(origin)?;1405 1406 let target_collection = Self::get_collection(collection_id)?;1407 Self::token_exists(&target_collection, item_id)?;14081409 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14101411 1412 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1413 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1414 Error::<T>::NoPermission);14151416 match target_collection.mode1417 {1418 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1419 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1420 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1421 _ => fail!(Error::<T>::UnexpectedCollectionType)1422 };14231424 Ok(())1425 }1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 #[weight = <T as Config>::WeightInfo::set_schema_version()]1442 #[transactional]1443 pub fn set_schema_version(1444 origin,1445 collection_id: CollectionId,1446 version: SchemaVersion1447 ) -> DispatchResult {1448 let sender = ensure_signed(origin)?;1449 let mut target_collection = Self::get_collection(collection_id)?;1450 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1451 target_collection.schema_version = version;1452 Self::save_collection(target_collection);14531454 Ok(())1455 }14561457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1470 #[transactional]1471 pub fn set_offchain_schema(1472 origin,1473 collection_id: CollectionId,1474 schema: Vec<u8>1475 ) -> DispatchResult {1476 let sender = ensure_signed(origin)?;1477 let mut target_collection = Self::get_collection(collection_id)?;1478 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14791480 1481 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14821483 target_collection.offchain_schema = schema;1484 Self::save_collection(target_collection);14851486 Ok(())1487 }14881489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1502 #[transactional]1503 pub fn set_const_on_chain_schema (1504 origin,1505 collection_id: CollectionId,1506 schema: Vec<u8>1507 ) -> DispatchResult {1508 let sender = ensure_signed(origin)?;1509 let mut target_collection = Self::get_collection(collection_id)?;1510 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15111512 1513 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15141515 target_collection.const_on_chain_schema = schema;1516 Self::save_collection(target_collection);15171518 Ok(())1519 }15201521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1534 #[transactional]1535 pub fn set_variable_on_chain_schema (1536 origin,1537 collection_id: CollectionId,1538 schema: Vec<u8>1539 ) -> DispatchResult {1540 let sender = ensure_signed(origin)?;1541 let mut target_collection = Self::get_collection(collection_id)?;1542 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15431544 1545 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15461547 target_collection.variable_on_chain_schema = schema;1548 Self::save_collection(target_collection);15491550 Ok(())1551 }15521553 1554 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1555 #[transactional]1556 pub fn set_chain_limits(1557 origin,1558 limits: ChainLimits1559 ) -> DispatchResult {15601561 #[cfg(not(feature = "runtime-benchmarks"))]1562 ensure_root(origin)?;15631564 <ChainLimit>::put(limits);1565 Ok(())1566 }15671568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1580 #[transactional]1581 pub fn enable_contract_sponsoring(1582 origin,1583 contract_address: T::AccountId,1584 enable: bool1585 ) -> DispatchResult {15861587 let sender = ensure_signed(origin)?;15881589 #[cfg(feature = "runtime-benchmarks")]1590 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15911592 Self::ensure_contract_owned(sender, &contract_address)?;15931594 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1595 Ok(())1596 }15971598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1616 #[transactional]1617 pub fn set_contract_sponsoring_rate_limit(1618 origin,1619 contract_address: T::AccountId,1620 rate_limit: T::BlockNumber1621 ) -> DispatchResult {1622 let sender = ensure_signed(origin)?;16231624 #[cfg(feature = "runtime-benchmarks")]1625 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16261627 Self::ensure_contract_owned(sender, &contract_address)?;1628 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1629 Ok(())1630 }16311632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1644 #[transactional]1645 pub fn toggle_contract_white_list(1646 origin,1647 contract_address: T::AccountId,1648 enable: bool1649 ) -> DispatchResult {1650 let sender = ensure_signed(origin)?;16511652 #[cfg(feature = "runtime-benchmarks")]1653 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16541655 Self::ensure_contract_owned(sender, &contract_address)?;1656 if enable {1657 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1658 } else {1659 <ContractWhiteListEnabled<T>>::remove(contract_address);1660 }1661 Ok(())1662 }1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1676 #[transactional]1677 pub fn add_to_contract_white_list(1678 origin,1679 contract_address: T::AccountId,1680 account_address: T::AccountId1681 ) -> DispatchResult {1682 let sender = ensure_signed(origin)?;16831684 #[cfg(feature = "runtime-benchmarks")]1685 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1686 1687 Self::ensure_contract_owned(sender, &contract_address)?; 1688 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1689 Ok(())1690 }16911692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1704 #[transactional]1705 pub fn remove_from_contract_white_list(1706 origin,1707 contract_address: T::AccountId,1708 account_address: T::AccountId1709 ) -> DispatchResult {1710 let sender = ensure_signed(origin)?;17111712 #[cfg(feature = "runtime-benchmarks")]1713 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17141715 Self::ensure_contract_owned(sender, &contract_address)?;1716 <ContractWhiteList<T>>::remove(contract_address, account_address);1717 Ok(())1718 }17191720 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1721 #[transactional]1722 pub fn set_collection_limits(1723 origin,1724 collection_id: u32,1725 new_limits: CollectionLimits<T::BlockNumber>,1726 ) -> DispatchResult {1727 let sender = ensure_signed(origin)?;1728 let mut target_collection = Self::get_collection(collection_id)?;1729 Self::check_owner_permissions(&target_collection, sender.clone())?;1730 let old_limits = &target_collection.limits;1731 let chain_limits = ChainLimit::get();17321733 1734 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1735 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1736 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1737 Error::<T>::CollectionLimitBoundsExceeded);17381739 1740 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1741 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17421743 ensure!(1744 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1745 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1746 Error::<T>::OwnerPermissionsCantBeReverted,1747 );17481749 target_collection.limits = new_limits;1750 Self::save_collection(target_collection);17511752 Ok(())1753 } 1754 }1755}17561757impl<T: Config> Module<T> {1758 pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1759 let target_collection = Self::get_collection(collection_id)?;17601761 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1762 Self::validate_create_item_args(&target_collection, &data)?;1763 Self::create_item_no_validation(&target_collection, owner, data)?;17641765 Ok(())1766 }17671768 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1769 1770 Self::is_correct_transfer(target_collection, &recipient)?;17711772 1773 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1774 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1775 Error::<T>::NoPermission);17761777 if target_collection.access == AccessMode::WhiteList {1778 Self::check_white_list(target_collection, &sender)?;1779 Self::check_white_list(target_collection, &recipient)?;1780 }17811782 match target_collection.mode1783 {1784 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1785 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1786 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1787 _ => ()1788 };17891790 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17911792 Ok(())1793 }17941795 pub fn create_multiple_items_internal(1796 sender: T::AccountId,1797 collection: &CollectionHandle<T>,1798 owner: T::AccountId,1799 items_data: Vec<CreateItemData>,1800 ) -> DispatchResult {1801 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18021803 for data in &items_data {1804 Self::validate_create_item_args(&collection, data)?;1805 }1806 for data in &items_data {1807 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1808 }18091810 Ok(())1811 }18121813 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1814 let collection_id = collection.id;18151816 1817 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1818 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1819 1820 Ok(())1821 }18221823 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1824 let collection_id = collection.id;18251826 1827 let total_items: u32 = ItemListIndex::get(collection_id)1828 .checked_add(amount)1829 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1830 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1831 .checked_add(amount)1832 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1833 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1834 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18351836 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1837 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1838 Self::check_white_list(collection, owner)?;1839 Self::check_white_list(collection, sender)?;1840 }18411842 Ok(())1843 }18441845 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1846 match target_collection.mode1847 {1848 CollectionMode::NFT => {1849 if let CreateItemData::NFT(data) = data {1850 1851 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1852 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1853 } else {1854 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1855 }1856 },1857 CollectionMode::Fungible(_) => {1858 if let CreateItemData::Fungible(_) = data {1859 } else {1860 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1861 }1862 },1863 CollectionMode::ReFungible => {1864 if let CreateItemData::ReFungible(data) = data {18651866 1867 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1868 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18691870 1871 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1872 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1873 } else {1874 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1875 }1876 },1877 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1878 };18791880 Ok(())1881 }18821883 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1884 match data1885 {1886 CreateItemData::NFT(data) => {1887 let item = NftItemType {1888 owner: owner.clone(),1889 const_data: data.const_data,1890 variable_data: data.variable_data1891 };18921893 Self::add_nft_item(collection, item)?;1894 },1895 CreateItemData::Fungible(data) => {1896 Self::add_fungible_item(collection, &owner, data.value)?;1897 },1898 CreateItemData::ReFungible(data) => {1899 let mut owner_list = Vec::new();1900 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19011902 let item = ReFungibleItemType {1903 owner: owner_list,1904 const_data: data.const_data,1905 variable_data: data.variable_data1906 };19071908 Self::add_refungible_item(collection, item)?;1909 }1910 };19111912 Ok(())1913 }19141915 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1916 let collection_id = collection.id;19171918 1919 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19201921 1922 let item = FungibleItemType {1923 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1924 };1925 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19261927 1928 let new_balance = <Balance<T>>::get(collection_id, owner)1929 .checked_add(value)1930 .ok_or(Error::<T>::NumOverflow)?;1931 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19321933 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1934 Ok(())1935 }19361937 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1938 let collection_id = collection.id;19391940 let current_index = <ItemListIndex>::get(collection_id)1941 .checked_add(1)1942 .ok_or(Error::<T>::NumOverflow)?;1943 let itemcopy = item.clone();19441945 ensure!(1946 item.owner.len() == 1,1947 Error::<T>::BadCreateRefungibleCall,1948 );1949 let item_owner = item.owner.first().expect("only one owner is defined");19501951 let value = item_owner.fraction;1952 let owner = item_owner.owner.clone();19531954 Self::add_token_index(collection_id, current_index, &owner)?;19551956 <ItemListIndex>::insert(collection_id, current_index);1957 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19581959 1960 let new_balance = <Balance<T>>::get(collection_id, &owner)1961 .checked_add(value)1962 .ok_or(Error::<T>::NumOverflow)?;1963 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19641965 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1966 Ok(())1967 }19681969 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1970 let collection_id = collection.id;19711972 let current_index = <ItemListIndex>::get(collection_id)1973 .checked_add(1)1974 .ok_or(Error::<T>::NumOverflow)?;19751976 let item_owner = item.owner.clone();1977 Self::add_token_index(collection_id, current_index, &item.owner)?;19781979 <ItemListIndex>::insert(collection_id, current_index);1980 <NftItemList<T>>::insert(collection_id, current_index, item);19811982 1983 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1984 .checked_add(1)1985 .ok_or(Error::<T>::NumOverflow)?;1986 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19871988 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1989 Ok(())1990 }19911992 fn burn_refungible_item(1993 collection: &CollectionHandle<T>,1994 item_id: TokenId,1995 owner: &T::AccountId,1996 ) -> DispatchResult {1997 let collection_id = collection.id;19981999 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2000 .ok_or(Error::<T>::TokenNotFound)?;2001 let rft_balance = token2002 .owner2003 .iter()2004 .find(|&i| i.owner == *owner)2005 .ok_or(Error::<T>::TokenNotFound)?;2006 Self::remove_token_index(collection_id, item_id, owner)?;20072008 2009 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2010 .checked_sub(rft_balance.fraction)2011 .ok_or(Error::<T>::NumOverflow)?;2012 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20132014 2015 let index = token2016 .owner2017 .iter()2018 .position(|i| i.owner == *owner)2019 .expect("owned item is exists");2020 token.owner.remove(index);2021 let owner_count = token.owner.len();20222023 2024 if owner_count == 0 {2025 <ReFungibleItemList<T>>::remove(collection_id, item_id);2026 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2027 }2028 else {2029 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2030 }20312032 Ok(())2033 }20342035 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2036 let collection_id = collection.id;20372038 let item = <NftItemList<T>>::get(collection_id, item_id)2039 .ok_or(Error::<T>::TokenNotFound)?;2040 Self::remove_token_index(collection_id, item_id, &item.owner)?;20412042 2043 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2044 .checked_sub(1)2045 .ok_or(Error::<T>::NumOverflow)?;2046 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2047 <NftItemList<T>>::remove(collection_id, item_id);2048 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20492050 Ok(())2051 }20522053 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2054 let collection_id = collection.id;20552056 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2057 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20582059 2060 let new_balance = <Balance<T>>::get(collection_id, owner)2061 .checked_sub(value)2062 .ok_or(Error::<T>::NumOverflow)?;2063 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20642065 if balance.value - value > 0 {2066 balance.value -= value;2067 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2068 }2069 else {2070 <FungibleItemList<T>>::remove(collection_id, owner);2071 }20722073 Ok(())2074 }20752076 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2077 Ok(<CollectionById<T>>::get(collection_id)2078 .map(|collection| CollectionHandle {2079 id: collection_id,2080 collection2081 })2082 .ok_or(Error::<T>::CollectionNotFound)?)2083 }20842085 fn save_collection(collection: CollectionHandle<T>) {2086 <CollectionById<T>>::insert(collection.id, collection.collection);2087 }20882089 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2090 ensure!(2091 subject == target_collection.owner,2092 Error::<T>::NoPermission2093 );20942095 Ok(())2096 }20972098 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2099 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2100 }21012102 fn check_owner_or_admin_permissions(2103 collection: &CollectionHandle<T>,2104 subject: T::AccountId,2105 ) -> DispatchResult {2106 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21072108 Ok(())2109 }21102111 fn owned_amount(2112 subject: T::AccountId,2113 target_collection: &CollectionHandle<T>,2114 item_id: TokenId,2115 ) -> Option<u128> {2116 let collection_id = target_collection.id;21172118 match target_collection.mode {2119 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2120 .then(|| 1),2121 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2122 .value),2123 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2124 .owner2125 .iter()2126 .find(|i| i.owner == subject)2127 .map(|i| i.fraction),2128 CollectionMode::Invalid => None,2129 }2130 }21312132 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2133 match target_collection.mode {2134 CollectionMode::Fungible(_) => true,2135 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2136 }2137 }21382139 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2140 let collection_id = collection.id;21412142 let mes = Error::<T>::AddresNotInWhiteList;2143 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21442145 Ok(())2146 }21472148 2149 2150 fn token_exists(2151 target_collection: &CollectionHandle<T>,2152 item_id: TokenId,2153 ) -> DispatchResult {2154 let collection_id = target_collection.id;2155 let exists = match target_collection.mode2156 {2157 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2158 CollectionMode::Fungible(_) => true,2159 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2160 _ => false2161 };21622163 ensure!(exists == true, Error::<T>::TokenNotFound);2164 Ok(())2165 }21662167 fn transfer_fungible(2168 collection: &CollectionHandle<T>,2169 value: u128,2170 owner: &T::AccountId,2171 recipient: &T::AccountId,2172 ) -> DispatchResult {2173 let collection_id = collection.id;21742175 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2176 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21772178 2179 Self::add_fungible_item(collection, recipient, value)?;21802181 2182 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21832184 2185 if balance.value == value {2186 <FungibleItemList<T>>::remove(collection_id, owner);2187 }2188 else {2189 balance.value -= value;2190 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2191 }21922193 Ok(())2194 }21952196 fn transfer_refungible(2197 collection: &CollectionHandle<T>,2198 item_id: TokenId,2199 value: u128,2200 owner: T::AccountId,2201 new_owner: T::AccountId,2202 ) -> DispatchResult {2203 let collection_id = collection.id;2204 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2205 .ok_or(Error::<T>::TokenNotFound)?;22062207 let item = full_item2208 .owner2209 .iter()2210 .filter(|i| i.owner == owner)2211 .next()2212 .ok_or(Error::<T>::TokenNotFound)?;2213 let amount = item.fraction;22142215 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22162217 2218 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2219 .checked_sub(value)2220 .ok_or(Error::<T>::NumOverflow)?;2221 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22222223 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2224 .checked_add(value)2225 .ok_or(Error::<T>::NumOverflow)?;2226 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22272228 let old_owner = item.owner.clone();2229 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22302231 2232 if amount == value && !new_owner_has_account {2233 2234 2235 let mut new_full_item = full_item.clone();2236 new_full_item2237 .owner2238 .iter_mut()2239 .find(|i| i.owner == owner)2240 .expect("old owner does present in refungible")2241 .owner = new_owner.clone();2242 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22432244 2245 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2246 } else {2247 let mut new_full_item = full_item.clone();2248 new_full_item2249 .owner2250 .iter_mut()2251 .find(|i| i.owner == owner)2252 .expect("old owner does present in refungible")2253 .fraction -= value;22542255 2256 if new_owner_has_account {2257 2258 new_full_item2259 .owner2260 .iter_mut()2261 .find(|i| i.owner == new_owner)2262 .expect("new owner has account")2263 .fraction += value;2264 } else {2265 2266 new_full_item.owner.push(Ownership {2267 owner: new_owner.clone(),2268 fraction: value,2269 });2270 Self::add_token_index(collection_id, item_id, &new_owner)?;2271 }22722273 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2274 }22752276 Ok(())2277 }22782279 fn transfer_nft(2280 collection: &CollectionHandle<T>,2281 item_id: TokenId,2282 sender: T::AccountId,2283 new_owner: T::AccountId,2284 ) -> DispatchResult {2285 let collection_id = collection.id;2286 let mut item = <NftItemList<T>>::get(collection_id, item_id)2287 .ok_or(Error::<T>::TokenNotFound)?;22882289 ensure!(2290 sender == item.owner,2291 Error::<T>::MustBeTokenOwner2292 );22932294 2295 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2296 .checked_sub(1)2297 .ok_or(Error::<T>::NumOverflow)?;2298 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22992300 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2301 .checked_add(1)2302 .ok_or(Error::<T>::NumOverflow)?;2303 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23042305 2306 let old_owner = item.owner.clone();2307 item.owner = new_owner.clone();2308 <NftItemList<T>>::insert(collection_id, item_id, item);23092310 2311 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23122313 Ok(())2314 }2315 2316 fn set_re_fungible_variable_data(2317 collection: &CollectionHandle<T>,2318 item_id: TokenId,2319 data: Vec<u8>2320 ) -> DispatchResult {2321 let collection_id = collection.id;2322 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2323 .ok_or(Error::<T>::TokenNotFound)?;23242325 item.variable_data = data;23262327 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23282329 Ok(())2330 }23312332 fn set_nft_variable_data(2333 collection: &CollectionHandle<T>,2334 item_id: TokenId,2335 data: Vec<u8>2336 ) -> DispatchResult {2337 let collection_id = collection.id;2338 let mut item = <NftItemList<T>>::get(collection_id, item_id)2339 .ok_or(Error::<T>::TokenNotFound)?;2340 2341 item.variable_data = data;23422343 <NftItemList<T>>::insert(collection_id, item_id, item);2344 2345 Ok(())2346 }23472348 fn init_collection(item: &Collection<T>) {2349 2350 assert!(2351 item.decimal_points <= MAX_DECIMAL_POINTS,2352 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2353 );2354 assert!(2355 item.name.len() <= 64,2356 "Collection name can not be longer than 63 char"2357 );2358 assert!(2359 item.name.len() <= 256,2360 "Collection description can not be longer than 255 char"2361 );2362 assert!(2363 item.token_prefix.len() <= 16,2364 "Token prefix can not be longer than 15 char"2365 );23662367 2368 let next_id = CreatedCollectionCount::get()2369 .checked_add(1)2370 .unwrap();23712372 CreatedCollectionCount::put(next_id);2373 }23742375 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2376 let current_index = <ItemListIndex>::get(collection_id)2377 .checked_add(1)2378 .unwrap();23792380 let item_owner = item.owner.clone();2381 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23822383 <ItemListIndex>::insert(collection_id, current_index);23842385 2386 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2387 .checked_add(1)2388 .unwrap();2389 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2390 }23912392 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2393 let current_index = <ItemListIndex>::get(collection_id)2394 .checked_add(1)2395 .unwrap();23962397 Self::add_token_index(collection_id, current_index, owner).unwrap();23982399 <ItemListIndex>::insert(collection_id, current_index);24002401 2402 let new_balance = <Balance<T>>::get(collection_id, owner)2403 .checked_add(item.value)2404 .unwrap();2405 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2406 }24072408 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2409 let current_index = <ItemListIndex>::get(collection_id)2410 .checked_add(1)2411 .unwrap();24122413 let value = item.owner.first().unwrap().fraction;2414 let owner = item.owner.first().unwrap().owner.clone();24152416 Self::add_token_index(collection_id, current_index, &owner).unwrap();24172418 <ItemListIndex>::insert(collection_id, current_index);24192420 2421 let new_balance = <Balance<T>>::get(collection_id, &owner)2422 .checked_add(value)2423 .unwrap();2424 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2425 }24262427 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2428 2429 if <AccountItemCount<T>>::contains_key(owner) {24302431 2432 let count = <AccountItemCount<T>>::get(owner);2433 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24342435 <AccountItemCount<T>>::insert(owner.clone(), count2436 .checked_add(1)2437 .ok_or(Error::<T>::NumOverflow)?);2438 }2439 else {2440 <AccountItemCount<T>>::insert(owner.clone(), 1);2441 }24422443 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2444 if list_exists {2445 let mut list = <AddressTokens<T>>::get(collection_id, owner);2446 let item_contains = list.contains(&item_index.clone());24472448 if !item_contains {2449 list.push(item_index.clone());2450 }24512452 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2453 } else {2454 let mut itm = Vec::new();2455 itm.push(item_index.clone());2456 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2457 }24582459 Ok(())2460 }24612462 fn remove_token_index(2463 collection_id: CollectionId,2464 item_index: TokenId,2465 owner: &T::AccountId,2466 ) -> DispatchResult {24672468 2469 <AccountItemCount<T>>::insert(owner.clone(), 2470 <AccountItemCount<T>>::get(owner)2471 .checked_sub(1)2472 .ok_or(Error::<T>::NumOverflow)?);247324742475 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2476 if list_exists {2477 let mut list = <AddressTokens<T>>::get(collection_id, owner);2478 let item_contains = list.contains(&item_index.clone());24792480 if item_contains {2481 list.retain(|&item| item != item_index);2482 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2483 }2484 }24852486 Ok(())2487 }24882489 fn move_token_index(2490 collection_id: CollectionId,2491 item_index: TokenId,2492 old_owner: &T::AccountId,2493 new_owner: &T::AccountId,2494 ) -> DispatchResult {2495 Self::remove_token_index(collection_id, item_index, old_owner)?;2496 Self::add_token_index(collection_id, item_index, new_owner)?;24972498 Ok(())2499 }2500 2501 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2502 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25032504 Ok(())2505 }2506}2507250825092510251125122513pub type Multiplier = FixedU128;25142515type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2516251725182519#[derive(Encode, Decode, Clone, Eq, PartialEq)]2520pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25212522impl<T: Config + Send + Sync> sp_std::fmt::Debug 2523 for ChargeTransactionPayment<T>2524{2525 #[cfg(feature = "std")]2526 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2527 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2528 }2529 #[cfg(not(feature = "std"))]2530 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2531 Ok(())2532 }2533}25342535impl<T: Config> ChargeTransactionPayment<T>2536where2537 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2538 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2539 T::AccountId: AsRef<[u8]>,2540 T::AccountId: UncheckedFrom<T::Hash>,2541{2542 fn traditional_fee(2543 len: usize,2544 info: &DispatchInfoOf<T::Call>,2545 tip: BalanceOf<T>,2546 ) -> BalanceOf<T>2547 where2548 T::Call: Dispatchable<Info = DispatchInfo>,2549 {2550 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2551 }25522553 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2554 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2555 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2556 let len_saturation = max_block_length as u64 / (len as u64).max(1);2557 let coefficient: BalanceOf<T> = weight_saturation2558 .min(len_saturation)2559 .saturated_into::<BalanceOf<T>>();2560 final_fee2561 .saturating_mul(coefficient)2562 .saturated_into::<TransactionPriority>()2563 }25642565 fn withdraw_fee(2566 &self,2567 who: &T::AccountId,2568 call: &T::Call,2569 info: &DispatchInfoOf<T::Call>,2570 len: usize,2571 ) -> Result<2572 (2573 BalanceOf<T>,2574 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2575 ),2576 TransactionValidityError,2577 > {2578 let tip = self.0;25792580 let fee = Self::traditional_fee(len, info, tip);25812582 2583 if fee.is_zero() {2584 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2585 .map(|i| (fee, i));2586 }25872588 2589 2590 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2591 Some(Call::create_item(collection_id, _owner, _properties)) => {2592 let collection = <CollectionById<T>>::get(collection_id)?;25932594 2595 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25962597 let limit = collection.limits.sponsor_transfer_timeout;2598 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2599 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2600 let limit_time = last_tx_block + limit.into();2601 if block_number <= limit_time {2602 return None;2603 }2604 }2605 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26062607 2608 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2609 collection.sponsorship.sponsor()2610 .cloned()2611 } else {2612 None2613 }2614 }2615 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2616 let collection = <CollectionById<T>>::get(collection_id)?;2617 2618 let mut sponsor_transfer = false;2619 if collection.sponsorship.confirmed() {26202621 let collection_limits = collection.limits;2622 let collection_mode = collection.mode;2623 2624 2625 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2626 sponsor_transfer = match collection_mode {2627 CollectionMode::NFT => {2628 2629 2630 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2631 collection_limits.sponsor_transfer_timeout2632 } else {2633 ChainLimit::get().nft_sponsor_transfer_timeout2634 };2635 2636 let mut sponsored = true;2637 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2638 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2639 let limit_time = last_tx_block + limit.into();2640 if block_number <= limit_time {2641 sponsored = false;2642 }2643 }2644 if sponsored {2645 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2646 }26472648 sponsored2649 }2650 CollectionMode::Fungible(_) => {2651 2652 2653 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2654 collection_limits.sponsor_transfer_timeout2655 } else {2656 ChainLimit::get().fungible_sponsor_transfer_timeout2657 };2658 2659 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2660 let mut sponsored = true;2661 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2662 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2663 let limit_time = last_tx_block + limit.into();2664 if block_number <= limit_time {2665 sponsored = false;2666 }2667 }2668 if sponsored {2669 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2670 }26712672 sponsored2673 }2674 CollectionMode::ReFungible => {2675 2676 2677 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2678 collection_limits.sponsor_transfer_timeout2679 } else {2680 ChainLimit::get().refungible_sponsor_transfer_timeout2681 };2682 2683 let mut sponsored = true;2684 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2685 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2686 let limit_time = last_tx_block + limit.into();2687 if block_number <= limit_time {2688 sponsored = false;2689 }2690 }2691 if sponsored {2692 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2693 }26942695 sponsored2696 }2697 _ => {2698 false2699 },2700 };2701 }27022703 if !sponsor_transfer {2704 None2705 } else {2706 collection.sponsorship.sponsor()2707 .cloned()2708 }2709 }27102711 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2712 let mut sponsor_metadata_changes = false;27132714 let collection = <CollectionById<T>>::get(collection_id)?;27152716 if2717 collection.sponsorship.confirmed() &&2718 2719 2720 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2721 data.len() <= collection.limits.sponsored_data_size as usize2722 {2723 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2724 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27252726 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2727 .map(|last_block| block_number - last_block > rate_limit)2728 .unwrap_or(true) 2729 {2730 sponsor_metadata_changes = true;2731 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2732 }2733 }2734 }27352736 if !sponsor_metadata_changes {2737 None2738 } else {2739 collection.sponsorship.sponsor().cloned()2740 }2741 }27422743 _ => None,2744 })();27452746 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2747 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27482749 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27502751 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2752 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2753 2754 if !owned_contract && white_list_enabled {2755 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2756 return Err(InvalidTransaction::Call.into());2757 }2758 }2759 },2760 _ => {},2761 }27622763 2764 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27652766 2767 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27682769 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2770 &who,2771 code_hash,2772 salt,2773 );2774 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27752776 None2777 },27782779 2780 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27812782 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2783 &who,2784 &T::Hashing::hash(&_code),2785 _salt,2786 );27872788 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27892790 None2791 }27922793 2794 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27952796 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27972798 let mut sponsor_transfer = false;2799 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2800 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2801 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2802 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2803 let limit_time = last_tx_block + rate_limit;28042805 if block_number >= limit_time {2806 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2807 sponsor_transfer = true;2808 }2809 } else {2810 sponsor_transfer = false;2811 }2812 2813 if sponsor_transfer {2814 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2815 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2816 return Some(called_contract);2817 }2818 }2819 }28202821 None2822 },28232824 _ => None,2825 });28262827 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28282829 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2830 .map(|i| (fee, i))2831 }2832}283328342835impl<T: Config + Send + Sync> SignedExtension2836 for ChargeTransactionPayment<T>2837where2838 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2839 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2840 T::AccountId: AsRef<[u8]>,2841 T::AccountId: UncheckedFrom<T::Hash>,2842{2843 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2844 type AccountId = T::AccountId;2845 type Call = T::Call;2846 type AdditionalSigned = ();2847 type Pre = (2848 2849 BalanceOf<T>,2850 2851 Self::AccountId,2852 2853 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2854 );2855 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2856 Ok(())2857 }28582859 fn validate(2860 &self,2861 who: &Self::AccountId,2862 call: &Self::Call,2863 info: &DispatchInfoOf<Self::Call>,2864 len: usize,2865 ) -> TransactionValidity {2866 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2867 Ok(ValidTransaction {2868 priority: Self::get_priority(len, info, fee),2869 ..Default::default()2870 })2871 }28722873 fn pre_dispatch(2874 self,2875 who: &Self::AccountId,2876 call: &Self::Call,2877 info: &DispatchInfoOf<Self::Call>,2878 len: usize,2879 ) -> Result<Self::Pre, TransactionValidityError> {2880 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2881 Ok((self.0, who.clone(), imbalance))2882 }28832884 fn post_dispatch(2885 pre: Self::Pre,2886 info: &DispatchInfoOf<Self::Call>,2887 post_info: &PostDispatchInfoOf<Self::Call>,2888 len: usize,2889 _result: &DispatchResult,2890 ) -> Result<(), TransactionValidityError> {2891 let (tip, who, imbalance) = pre;2892 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2893 len as u32,2894 info,2895 post_info,2896 tip,2897 );2898 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2899 Ok(())2900 }2901}29022903