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)?;845846 Self::toggle_white_list_internal(847 &sender,848 &collection,849 &address,850 true,851 )?;852853 Ok(())854 }855856 857 858 859 860 861 862 863 864 865 866 867 868 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]869 #[transactional]870 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{871872 let sender = ensure_signed(origin)?;873 let collection = Self::get_collection(collection_id)?;874875 Self::toggle_white_list_internal(876 &sender,877 &collection,878 &address,879 false,880 )?;881882 Ok(())883 }884885 886 887 888 889 890 891 892 893 894 895 896 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]897 #[transactional]898 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult899 {900 let sender = ensure_signed(origin)?;901902 let mut target_collection = Self::get_collection(collection_id)?;903 Self::check_owner_permissions(&target_collection, sender)?;904 target_collection.access = mode;905 Self::save_collection(target_collection);906907 Ok(())908 }909910 911 912 913 914 915 916 917 918 919 920 921 922 923 #[weight = <T as Config>::WeightInfo::set_mint_permission()]924 #[transactional]925 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult926 {927 let sender = ensure_signed(origin)?;928929 let mut target_collection = Self::get_collection(collection_id)?;930 Self::check_owner_permissions(&target_collection, sender)?;931 target_collection.mint_mode = mint_permission;932 Self::save_collection(target_collection);933934 Ok(())935 }936937 938 939 940 941 942 943 944 945 946 947 948 #[weight = <T as Config>::WeightInfo::change_collection_owner()]949 #[transactional]950 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {951952 let sender = ensure_signed(origin)?;953 let mut target_collection = Self::get_collection(collection_id)?;954 Self::check_owner_permissions(&target_collection, sender)?;955 target_collection.owner = new_owner;956 Self::save_collection(target_collection);957958 Ok(())959 }960961 962 963 964 965 966 967 968 969 970 971 972 973 974 #[weight = <T as Config>::WeightInfo::add_collection_admin()]975 #[transactional]976 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {977978 let sender = ensure_signed(origin)?;979 let collection = Self::get_collection(collection_id)?;980 Self::check_owner_or_admin_permissions(&collection, sender)?;981 let mut admin_arr = <AdminList<T>>::get(collection_id);982983 match admin_arr.binary_search(&new_admin_id) {984 Ok(_) => {},985 Err(idx) => {986 let limits = ChainLimit::get();987 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);988 admin_arr.insert(idx, new_admin_id);989 <AdminList<T>>::insert(collection_id, admin_arr);990 }991 }992 Ok(())993 }994995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1008 #[transactional]1009 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10101011 let sender = ensure_signed(origin)?;1012 let collection = Self::get_collection(collection_id)?;1013 Self::check_owner_or_admin_permissions(&collection, sender)?;1014 let mut admin_arr = <AdminList<T>>::get(collection_id);10151016 match admin_arr.binary_search(&account_id) {1017 Ok(idx) => {1018 admin_arr.remove(idx);1019 <AdminList<T>>::insert(collection_id, admin_arr);1020 },1021 Err(_) => {}1022 }1023 Ok(())1024 }10251026 1027 1028 1029 1030 1031 1032 1033 1034 1035 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1036 #[transactional]1037 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10381039 let sender = ensure_signed(origin)?;1040 let mut target_collection = Self::get_collection(collection_id)?;1041 Self::check_owner_permissions(&target_collection, sender)?;10421043 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1044 Self::save_collection(target_collection);10451046 Ok(())1047 }10481049 1050 1051 1052 1053 1054 1055 1056 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1057 #[transactional]1058 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10591060 let sender = ensure_signed(origin)?;10611062 let mut target_collection = Self::get_collection(collection_id)?;1063 ensure!(1064 target_collection.sponsorship.pending_sponsor() == Some(&sender),1065 Error::<T>::ConfirmUnsetSponsorFail1066 );10671068 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1069 Self::save_collection(target_collection);10701071 Ok(())1072 }10731074 1075 1076 1077 1078 1079 1080 1081 1082 1083 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1084 #[transactional]1085 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10861087 let sender = ensure_signed(origin)?;10881089 let mut target_collection = Self::get_collection(collection_id)?;1090 Self::check_owner_permissions(&target_collection, sender)?;10911092 target_collection.sponsorship = SponsorshipState::Disabled;1093 Self::save_collection(target_collection);10941095 Ok(())1096 }10971098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 11211122 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1123 #[transactional]1124 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1125 let sender = ensure_signed(origin)?;1126 Self::create_item_internal(sender, collection_id, owner, data)1127 }11281129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148 .map(|data| { data.len() })1149 .sum())]1150 #[transactional]1151 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154 let sender = ensure_signed(origin)?;11551156 let target_collection = Self::get_collection(collection_id)?;11571158 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160 for data in &items_data {1161 Self::validate_create_item_args(&target_collection, data)?;1162 }1163 for data in &items_data {1164 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165 }11661167 Ok(())1168 }11691170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 #[weight = <T as Config>::WeightInfo::burn_item()]1184 #[transactional]1185 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187 let sender = ensure_signed(origin)?;11881189 1190 let target_collection = Self::get_collection(collection_id)?;1191 ensure!(1192 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193 (1194 target_collection.limits.owner_can_transfer &&1195 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196 ),1197 Error::<T>::NoPermission1198 );11991200 if target_collection.access == AccessMode::WhiteList {1201 Self::check_white_list(&target_collection, &sender)?;1202 }12031204 match target_collection.mode1205 {1206 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1208 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209 _ => ()1210 };12111212 1213 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215 Ok(())1216 }12171218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 #[weight = <T as Config>::WeightInfo::transfer()]1242 #[transactional]1243 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244 let sender = ensure_signed(origin)?;1245 let collection = Self::get_collection(collection_id)?;12461247 Self::transfer_internal(sender, recipient, &collection, item_id, value)1248 }12491250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 #[weight = <T as Config>::WeightInfo::approve()]1266 #[transactional]1267 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269 let sender = ensure_signed(origin)?;1270 let collection = Self::get_collection(collection_id)?;12711272 Self::approve_internal(sender, spender, &collection, item_id, amount)?;12731274 Ok(())1275 }1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 #[weight = <T as Config>::WeightInfo::transfer_from()]1297 #[transactional]1298 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12991300 let sender = ensure_signed(origin)?;1301 let collection = Self::get_collection(collection_id)?;13021303 Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;13041305 Ok(())1306 }13071308 1309 13101311 1312 1313 1314 13151316 13171318 13191320 1321 13221323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1336 #[transactional]1337 pub fn set_variable_meta_data (1338 origin,1339 collection_id: CollectionId,1340 item_id: TokenId,1341 data: Vec<u8>1342 ) -> DispatchResult {1343 let sender = ensure_signed(origin)?;1344 1345 let collection = Self::get_collection(collection_id)?;13461347 Self::set_variable_meta_data_internal(sender, &collection, item_id, data)?;13481349 Ok(())1350 }1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 #[weight = <T as Config>::WeightInfo::set_schema_version()]1367 #[transactional]1368 pub fn set_schema_version(1369 origin,1370 collection_id: CollectionId,1371 version: SchemaVersion1372 ) -> DispatchResult {1373 let sender = ensure_signed(origin)?;1374 let mut target_collection = Self::get_collection(collection_id)?;1375 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1376 target_collection.schema_version = version;1377 Self::save_collection(target_collection);13781379 Ok(())1380 }13811382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1395 #[transactional]1396 pub fn set_offchain_schema(1397 origin,1398 collection_id: CollectionId,1399 schema: Vec<u8>1400 ) -> DispatchResult {1401 let sender = ensure_signed(origin)?;1402 let mut target_collection = Self::get_collection(collection_id)?;1403 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14041405 1406 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14071408 target_collection.offchain_schema = schema;1409 Self::save_collection(target_collection);14101411 Ok(())1412 }14131414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1427 #[transactional]1428 pub fn set_const_on_chain_schema (1429 origin,1430 collection_id: CollectionId,1431 schema: Vec<u8>1432 ) -> DispatchResult {1433 let sender = ensure_signed(origin)?;1434 let mut target_collection = Self::get_collection(collection_id)?;1435 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14361437 1438 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14391440 target_collection.const_on_chain_schema = schema;1441 Self::save_collection(target_collection);14421443 Ok(())1444 }14451446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1459 #[transactional]1460 pub fn set_variable_on_chain_schema (1461 origin,1462 collection_id: CollectionId,1463 schema: Vec<u8>1464 ) -> DispatchResult {1465 let sender = ensure_signed(origin)?;1466 let mut target_collection = Self::get_collection(collection_id)?;1467 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14681469 1470 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14711472 target_collection.variable_on_chain_schema = schema;1473 Self::save_collection(target_collection);14741475 Ok(())1476 }14771478 1479 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1480 #[transactional]1481 pub fn set_chain_limits(1482 origin,1483 limits: ChainLimits1484 ) -> DispatchResult {14851486 #[cfg(not(feature = "runtime-benchmarks"))]1487 ensure_root(origin)?;14881489 <ChainLimit>::put(limits);1490 Ok(())1491 }14921493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1505 #[transactional]1506 pub fn enable_contract_sponsoring(1507 origin,1508 contract_address: T::AccountId,1509 enable: bool1510 ) -> DispatchResult {15111512 let sender = ensure_signed(origin)?;15131514 #[cfg(feature = "runtime-benchmarks")]1515 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15161517 Self::ensure_contract_owned(sender, &contract_address)?;15181519 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1520 Ok(())1521 }15221523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1541 #[transactional]1542 pub fn set_contract_sponsoring_rate_limit(1543 origin,1544 contract_address: T::AccountId,1545 rate_limit: T::BlockNumber1546 ) -> DispatchResult {1547 let sender = ensure_signed(origin)?;15481549 #[cfg(feature = "runtime-benchmarks")]1550 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15511552 Self::ensure_contract_owned(sender, &contract_address)?;1553 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1554 Ok(())1555 }15561557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1569 #[transactional]1570 pub fn toggle_contract_white_list(1571 origin,1572 contract_address: T::AccountId,1573 enable: bool1574 ) -> DispatchResult {1575 let sender = ensure_signed(origin)?;15761577 #[cfg(feature = "runtime-benchmarks")]1578 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15791580 Self::ensure_contract_owned(sender, &contract_address)?;1581 if enable {1582 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1583 } else {1584 <ContractWhiteListEnabled<T>>::remove(contract_address);1585 }1586 Ok(())1587 }1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1601 #[transactional]1602 pub fn add_to_contract_white_list(1603 origin,1604 contract_address: T::AccountId,1605 account_address: T::AccountId1606 ) -> DispatchResult {1607 let sender = ensure_signed(origin)?;16081609 #[cfg(feature = "runtime-benchmarks")]1610 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1611 1612 Self::ensure_contract_owned(sender, &contract_address)?; 1613 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1614 Ok(())1615 }16161617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1629 #[transactional]1630 pub fn remove_from_contract_white_list(1631 origin,1632 contract_address: T::AccountId,1633 account_address: T::AccountId1634 ) -> DispatchResult {1635 let sender = ensure_signed(origin)?;16361637 #[cfg(feature = "runtime-benchmarks")]1638 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16391640 Self::ensure_contract_owned(sender, &contract_address)?;1641 <ContractWhiteList<T>>::remove(contract_address, account_address);1642 Ok(())1643 }16441645 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1646 #[transactional]1647 pub fn set_collection_limits(1648 origin,1649 collection_id: u32,1650 new_limits: CollectionLimits<T::BlockNumber>,1651 ) -> DispatchResult {1652 let sender = ensure_signed(origin)?;1653 let mut target_collection = Self::get_collection(collection_id)?;1654 Self::check_owner_permissions(&target_collection, sender.clone())?;1655 let old_limits = &target_collection.limits;1656 let chain_limits = ChainLimit::get();16571658 1659 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1660 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1661 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1662 Error::<T>::CollectionLimitBoundsExceeded);16631664 1665 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1666 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16671668 ensure!(1669 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1670 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1671 Error::<T>::OwnerPermissionsCantBeReverted,1672 );16731674 target_collection.limits = new_limits;1675 Self::save_collection(target_collection);16761677 Ok(())1678 } 1679 }1680}16811682impl<T: Config> Module<T> {1683 pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1684 let target_collection = Self::get_collection(collection_id)?;16851686 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1687 Self::validate_create_item_args(&target_collection, &data)?;1688 Self::create_item_no_validation(&target_collection, owner, data)?;16891690 Ok(())1691 }16921693 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1694 1695 Self::is_correct_transfer(target_collection, &recipient)?;16961697 1698 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1699 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1700 Error::<T>::NoPermission);17011702 if target_collection.access == AccessMode::WhiteList {1703 Self::check_white_list(target_collection, &sender)?;1704 Self::check_white_list(target_collection, &recipient)?;1705 }17061707 match target_collection.mode1708 {1709 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1710 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1711 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1712 _ => ()1713 };17141715 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17161717 Ok(())1718 }17191720 pub fn approve_internal(1721 sender: T::AccountId,1722 spender: T::AccountId,1723 collection: &CollectionHandle<T>,1724 item_id: TokenId,1725 amount: u128,1726 ) -> DispatchResult {1727 Self::token_exists(&collection, item_id)?;17281729 1730 let bypasses_limits = collection.limits.owner_can_transfer &&1731 Self::is_owner_or_admin_permissions(1732 &collection,1733 sender.clone(),1734 );17351736 let allowance_limit = if bypasses_limits {1737 None1738 } else if let Some(amount) = Self::owned_amount(1739 sender.clone(),1740 &collection,1741 item_id,1742 ) {1743 Some(amount)1744 } else {1745 fail!(Error::<T>::NoPermission);1746 };17471748 if collection.access == AccessMode::WhiteList {1749 Self::check_white_list(&collection, &sender)?;1750 Self::check_white_list(&collection, &spender)?;1751 }17521753 let allowance: u128 = amount1754 .checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1755 .ok_or(Error::<T>::NumOverflow)?;1756 if let Some(limit) = allowance_limit {1757 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1758 }1759 <Allowances<T>>::insert(collection.id, (item_id, &sender, &spender), allowance);17601761 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1762 Ok(())1763 }17641765 pub fn transfer_from_internal(1766 sender: T::AccountId,1767 from: T::AccountId,1768 recipient: T::AccountId,1769 collection: &CollectionHandle<T>,1770 item_id: TokenId,1771 amount: u128,1772 ) -> DispatchResult {1773 1774 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));17751776 1777 Self::is_correct_transfer(&collection, &recipient)?;17781779 1780 ensure!(1781 approval >= amount || 1782 (1783 collection.limits.owner_can_transfer &&1784 Self::is_owner_or_admin_permissions(&collection, sender.clone())1785 ),1786 Error::<T>::NoPermission1787 );17881789 if collection.access == AccessMode::WhiteList {1790 Self::check_white_list(&collection, &sender)?;1791 Self::check_white_list(&collection, &recipient)?;1792 }17931794 1795 let allowance = approval.saturating_sub(amount);1796 if allowance > 0 {1797 <Allowances<T>>::insert(collection.id, (item_id, &from, &sender), allowance);1798 } else {1799 <Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1800 }18011802 match collection.mode {1803 CollectionMode::NFT => {1804 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1805 }1806 CollectionMode::Fungible(_) => {1807 Self::transfer_fungible(&collection, amount, &from, &recipient)?1808 }1809 CollectionMode::ReFungible => {1810 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1811 }1812 _ => ()1813 };18141815 Ok(())1816 }18171818 pub fn set_variable_meta_data_internal(1819 sender: T::AccountId,1820 collection: &CollectionHandle<T>, 1821 item_id: TokenId,1822 data: Vec<u8>,1823 ) -> DispatchResult {1824 Self::token_exists(&collection, item_id)?;18251826 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18271828 1829 ensure!(Self::is_item_owner(sender.clone(), &collection, item_id) ||1830 Self::is_owner_or_admin_permissions(&collection, sender.clone()),1831 Error::<T>::NoPermission);18321833 match collection.mode1834 {1835 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1836 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1837 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1838 _ => fail!(Error::<T>::UnexpectedCollectionType)1839 };18401841 Ok(())1842 }18431844 pub fn create_multiple_items_internal(1845 sender: T::AccountId,1846 collection: &CollectionHandle<T>,1847 owner: T::AccountId,1848 items_data: Vec<CreateItemData>,1849 ) -> DispatchResult {1850 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18511852 for data in &items_data {1853 Self::validate_create_item_args(&collection, data)?;1854 }1855 for data in &items_data {1856 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1857 }18581859 Ok(())1860 }18611862 pub fn toggle_white_list_internal(1863 sender: &T::AccountId,1864 collection: &CollectionHandle<T>,1865 address: &T::AccountId,1866 whitelisted: bool,1867 ) -> DispatchResult {1868 Self::check_owner_or_admin_permissions(&collection, sender.clone())?;18691870 if whitelisted {1871 <WhiteList<T>>::insert(collection.id, address, true);1872 } else {1873 <WhiteList<T>>::remove(collection.id, address);1874 }18751876 Ok(())1877 }18781879 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1880 let collection_id = collection.id;18811882 1883 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1884 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1885 1886 Ok(())1887 }18881889 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1890 let collection_id = collection.id;18911892 1893 let total_items: u32 = ItemListIndex::get(collection_id)1894 .checked_add(amount)1895 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1896 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1897 .checked_add(amount)1898 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1899 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1900 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);19011902 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1903 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1904 Self::check_white_list(collection, owner)?;1905 Self::check_white_list(collection, sender)?;1906 }19071908 Ok(())1909 }19101911 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1912 match target_collection.mode1913 {1914 CollectionMode::NFT => {1915 if let CreateItemData::NFT(data) = data {1916 1917 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1918 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1919 } else {1920 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1921 }1922 },1923 CollectionMode::Fungible(_) => {1924 if let CreateItemData::Fungible(_) = data {1925 } else {1926 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1927 }1928 },1929 CollectionMode::ReFungible => {1930 if let CreateItemData::ReFungible(data) = data {19311932 1933 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1934 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19351936 1937 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1938 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1939 } else {1940 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1941 }1942 },1943 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1944 };19451946 Ok(())1947 }19481949 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1950 match data1951 {1952 CreateItemData::NFT(data) => {1953 let item = NftItemType {1954 owner: owner.clone(),1955 const_data: data.const_data,1956 variable_data: data.variable_data1957 };19581959 Self::add_nft_item(collection, item)?;1960 },1961 CreateItemData::Fungible(data) => {1962 Self::add_fungible_item(collection, &owner, data.value)?;1963 },1964 CreateItemData::ReFungible(data) => {1965 let mut owner_list = Vec::new();1966 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19671968 let item = ReFungibleItemType {1969 owner: owner_list,1970 const_data: data.const_data,1971 variable_data: data.variable_data1972 };19731974 Self::add_refungible_item(collection, item)?;1975 }1976 };19771978 Ok(())1979 }19801981 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1982 let collection_id = collection.id;19831984 1985 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19861987 1988 let item = FungibleItemType {1989 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1990 };1991 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19921993 1994 let new_balance = <Balance<T>>::get(collection_id, owner)1995 .checked_add(value)1996 .ok_or(Error::<T>::NumOverflow)?;1997 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19981999 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2000 Ok(())2001 }20022003 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {2004 let collection_id = collection.id;20052006 let current_index = <ItemListIndex>::get(collection_id)2007 .checked_add(1)2008 .ok_or(Error::<T>::NumOverflow)?;2009 let itemcopy = item.clone();20102011 ensure!(2012 item.owner.len() == 1,2013 Error::<T>::BadCreateRefungibleCall,2014 );2015 let item_owner = item.owner.first().expect("only one owner is defined");20162017 let value = item_owner.fraction;2018 let owner = item_owner.owner.clone();20192020 Self::add_token_index(collection_id, current_index, &owner)?;20212022 <ItemListIndex>::insert(collection_id, current_index);2023 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20242025 2026 let new_balance = <Balance<T>>::get(collection_id, &owner)2027 .checked_add(value)2028 .ok_or(Error::<T>::NumOverflow)?;2029 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);20302031 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2032 Ok(())2033 }20342035 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {2036 let collection_id = collection.id;20372038 let current_index = <ItemListIndex>::get(collection_id)2039 .checked_add(1)2040 .ok_or(Error::<T>::NumOverflow)?;20412042 let item_owner = item.owner.clone();2043 Self::add_token_index(collection_id, current_index, &item.owner)?;20442045 <ItemListIndex>::insert(collection_id, current_index);2046 <NftItemList<T>>::insert(collection_id, current_index, item);20472048 2049 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2050 .checked_add(1)2051 .ok_or(Error::<T>::NumOverflow)?;2052 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);20532054 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2055 Ok(())2056 }20572058 fn burn_refungible_item(2059 collection: &CollectionHandle<T>,2060 item_id: TokenId,2061 owner: &T::AccountId,2062 ) -> DispatchResult {2063 let collection_id = collection.id;20642065 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2066 .ok_or(Error::<T>::TokenNotFound)?;2067 let rft_balance = token2068 .owner2069 .iter()2070 .find(|&i| i.owner == *owner)2071 .ok_or(Error::<T>::TokenNotFound)?;2072 Self::remove_token_index(collection_id, item_id, owner)?;20732074 2075 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2076 .checked_sub(rft_balance.fraction)2077 .ok_or(Error::<T>::NumOverflow)?;2078 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20792080 2081 let index = token2082 .owner2083 .iter()2084 .position(|i| i.owner == *owner)2085 .expect("owned item is exists");2086 token.owner.remove(index);2087 let owner_count = token.owner.len();20882089 2090 if owner_count == 0 {2091 <ReFungibleItemList<T>>::remove(collection_id, item_id);2092 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2093 }2094 else {2095 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2096 }20972098 Ok(())2099 }21002101 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2102 let collection_id = collection.id;21032104 let item = <NftItemList<T>>::get(collection_id, item_id)2105 .ok_or(Error::<T>::TokenNotFound)?;2106 Self::remove_token_index(collection_id, item_id, &item.owner)?;21072108 2109 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2110 .checked_sub(1)2111 .ok_or(Error::<T>::NumOverflow)?;2112 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2113 <NftItemList<T>>::remove(collection_id, item_id);2114 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21152116 Ok(())2117 }21182119 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2120 let collection_id = collection.id;21212122 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2123 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21242125 2126 let new_balance = <Balance<T>>::get(collection_id, owner)2127 .checked_sub(value)2128 .ok_or(Error::<T>::NumOverflow)?;2129 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);21302131 if balance.value - value > 0 {2132 balance.value -= value;2133 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2134 }2135 else {2136 <FungibleItemList<T>>::remove(collection_id, owner);2137 }21382139 Ok(())2140 }21412142 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2143 Ok(<CollectionById<T>>::get(collection_id)2144 .map(|collection| CollectionHandle {2145 id: collection_id,2146 collection2147 })2148 .ok_or(Error::<T>::CollectionNotFound)?)2149 }21502151 fn save_collection(collection: CollectionHandle<T>) {2152 <CollectionById<T>>::insert(collection.id, collection.collection);2153 }21542155 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2156 ensure!(2157 subject == target_collection.owner,2158 Error::<T>::NoPermission2159 );21602161 Ok(())2162 }21632164 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2165 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2166 }21672168 fn check_owner_or_admin_permissions(2169 collection: &CollectionHandle<T>,2170 subject: T::AccountId,2171 ) -> DispatchResult {2172 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21732174 Ok(())2175 }21762177 fn owned_amount(2178 subject: T::AccountId,2179 target_collection: &CollectionHandle<T>,2180 item_id: TokenId,2181 ) -> Option<u128> {2182 let collection_id = target_collection.id;21832184 match target_collection.mode {2185 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2186 .then(|| 1),2187 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2188 .value),2189 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2190 .owner2191 .iter()2192 .find(|i| i.owner == subject)2193 .map(|i| i.fraction),2194 CollectionMode::Invalid => None,2195 }2196 }21972198 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2199 match target_collection.mode {2200 CollectionMode::Fungible(_) => true,2201 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2202 }2203 }22042205 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2206 let collection_id = collection.id;22072208 let mes = Error::<T>::AddresNotInWhiteList;2209 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);22102211 Ok(())2212 }22132214 2215 2216 fn token_exists(2217 target_collection: &CollectionHandle<T>,2218 item_id: TokenId,2219 ) -> DispatchResult {2220 let collection_id = target_collection.id;2221 let exists = match target_collection.mode2222 {2223 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2224 CollectionMode::Fungible(_) => true,2225 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2226 _ => false2227 };22282229 ensure!(exists == true, Error::<T>::TokenNotFound);2230 Ok(())2231 }22322233 fn transfer_fungible(2234 collection: &CollectionHandle<T>,2235 value: u128,2236 owner: &T::AccountId,2237 recipient: &T::AccountId,2238 ) -> DispatchResult {2239 let collection_id = collection.id;22402241 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2242 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22432244 2245 Self::add_fungible_item(collection, recipient, value)?;22462247 2248 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22492250 2251 if balance.value == value {2252 <FungibleItemList<T>>::remove(collection_id, owner);2253 }2254 else {2255 balance.value -= value;2256 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2257 }22582259 Ok(())2260 }22612262 fn transfer_refungible(2263 collection: &CollectionHandle<T>,2264 item_id: TokenId,2265 value: u128,2266 owner: T::AccountId,2267 new_owner: T::AccountId,2268 ) -> DispatchResult {2269 let collection_id = collection.id;2270 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2271 .ok_or(Error::<T>::TokenNotFound)?;22722273 let item = full_item2274 .owner2275 .iter()2276 .filter(|i| i.owner == owner)2277 .next()2278 .ok_or(Error::<T>::TokenNotFound)?;2279 let amount = item.fraction;22802281 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22822283 2284 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2285 .checked_sub(value)2286 .ok_or(Error::<T>::NumOverflow)?;2287 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22882289 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2290 .checked_add(value)2291 .ok_or(Error::<T>::NumOverflow)?;2292 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22932294 let old_owner = item.owner.clone();2295 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22962297 2298 if amount == value && !new_owner_has_account {2299 2300 2301 let mut new_full_item = full_item.clone();2302 new_full_item2303 .owner2304 .iter_mut()2305 .find(|i| i.owner == owner)2306 .expect("old owner does present in refungible")2307 .owner = new_owner.clone();2308 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23092310 2311 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2312 } else {2313 let mut new_full_item = full_item.clone();2314 new_full_item2315 .owner2316 .iter_mut()2317 .find(|i| i.owner == owner)2318 .expect("old owner does present in refungible")2319 .fraction -= value;23202321 2322 if new_owner_has_account {2323 2324 new_full_item2325 .owner2326 .iter_mut()2327 .find(|i| i.owner == new_owner)2328 .expect("new owner has account")2329 .fraction += value;2330 } else {2331 2332 new_full_item.owner.push(Ownership {2333 owner: new_owner.clone(),2334 fraction: value,2335 });2336 Self::add_token_index(collection_id, item_id, &new_owner)?;2337 }23382339 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2340 }23412342 Ok(())2343 }23442345 fn transfer_nft(2346 collection: &CollectionHandle<T>,2347 item_id: TokenId,2348 sender: T::AccountId,2349 new_owner: T::AccountId,2350 ) -> DispatchResult {2351 let collection_id = collection.id;2352 let mut item = <NftItemList<T>>::get(collection_id, item_id)2353 .ok_or(Error::<T>::TokenNotFound)?;23542355 ensure!(2356 sender == item.owner,2357 Error::<T>::MustBeTokenOwner2358 );23592360 2361 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2362 .checked_sub(1)2363 .ok_or(Error::<T>::NumOverflow)?;2364 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23652366 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2367 .checked_add(1)2368 .ok_or(Error::<T>::NumOverflow)?;2369 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23702371 2372 let old_owner = item.owner.clone();2373 item.owner = new_owner.clone();2374 <NftItemList<T>>::insert(collection_id, item_id, item);23752376 2377 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23782379 Ok(())2380 }2381 2382 fn set_re_fungible_variable_data(2383 collection: &CollectionHandle<T>,2384 item_id: TokenId,2385 data: Vec<u8>2386 ) -> DispatchResult {2387 let collection_id = collection.id;2388 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2389 .ok_or(Error::<T>::TokenNotFound)?;23902391 item.variable_data = data;23922393 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23942395 Ok(())2396 }23972398 fn set_nft_variable_data(2399 collection: &CollectionHandle<T>,2400 item_id: TokenId,2401 data: Vec<u8>2402 ) -> DispatchResult {2403 let collection_id = collection.id;2404 let mut item = <NftItemList<T>>::get(collection_id, item_id)2405 .ok_or(Error::<T>::TokenNotFound)?;2406 2407 item.variable_data = data;24082409 <NftItemList<T>>::insert(collection_id, item_id, item);2410 2411 Ok(())2412 }24132414 #[allow(dead_code)]2415 fn init_collection(item: &Collection<T>) {2416 2417 assert!(2418 item.decimal_points <= MAX_DECIMAL_POINTS,2419 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2420 );2421 assert!(2422 item.name.len() <= 64,2423 "Collection name can not be longer than 63 char"2424 );2425 assert!(2426 item.name.len() <= 256,2427 "Collection description can not be longer than 255 char"2428 );2429 assert!(2430 item.token_prefix.len() <= 16,2431 "Token prefix can not be longer than 15 char"2432 );24332434 2435 let next_id = CreatedCollectionCount::get()2436 .checked_add(1)2437 .unwrap();24382439 CreatedCollectionCount::put(next_id);2440 }24412442 #[allow(dead_code)]2443 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2444 let current_index = <ItemListIndex>::get(collection_id)2445 .checked_add(1)2446 .unwrap();24472448 let item_owner = item.owner.clone();2449 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24502451 <ItemListIndex>::insert(collection_id, current_index);24522453 2454 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2455 .checked_add(1)2456 .unwrap();2457 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2458 }24592460 #[allow(dead_code)]2461 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2462 let current_index = <ItemListIndex>::get(collection_id)2463 .checked_add(1)2464 .unwrap();24652466 Self::add_token_index(collection_id, current_index, owner).unwrap();24672468 <ItemListIndex>::insert(collection_id, current_index);24692470 2471 let new_balance = <Balance<T>>::get(collection_id, owner)2472 .checked_add(item.value)2473 .unwrap();2474 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2475 }24762477 #[allow(dead_code)]2478 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2479 let current_index = <ItemListIndex>::get(collection_id)2480 .checked_add(1)2481 .unwrap();24822483 let value = item.owner.first().unwrap().fraction;2484 let owner = item.owner.first().unwrap().owner.clone();24852486 Self::add_token_index(collection_id, current_index, &owner).unwrap();24872488 <ItemListIndex>::insert(collection_id, current_index);24892490 2491 let new_balance = <Balance<T>>::get(collection_id, &owner)2492 .checked_add(value)2493 .unwrap();2494 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2495 }24962497 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2498 2499 if <AccountItemCount<T>>::contains_key(owner) {25002501 2502 let count = <AccountItemCount<T>>::get(owner);2503 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25042505 <AccountItemCount<T>>::insert(owner.clone(), count2506 .checked_add(1)2507 .ok_or(Error::<T>::NumOverflow)?);2508 }2509 else {2510 <AccountItemCount<T>>::insert(owner.clone(), 1);2511 }25122513 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2514 if list_exists {2515 let mut list = <AddressTokens<T>>::get(collection_id, owner);2516 let item_contains = list.contains(&item_index.clone());25172518 if !item_contains {2519 list.push(item_index.clone());2520 }25212522 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2523 } else {2524 let mut itm = Vec::new();2525 itm.push(item_index.clone());2526 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2527 }25282529 Ok(())2530 }25312532 fn remove_token_index(2533 collection_id: CollectionId,2534 item_index: TokenId,2535 owner: &T::AccountId,2536 ) -> DispatchResult {25372538 2539 <AccountItemCount<T>>::insert(owner.clone(), 2540 <AccountItemCount<T>>::get(owner)2541 .checked_sub(1)2542 .ok_or(Error::<T>::NumOverflow)?);254325442545 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2546 if list_exists {2547 let mut list = <AddressTokens<T>>::get(collection_id, owner);2548 let item_contains = list.contains(&item_index.clone());25492550 if item_contains {2551 list.retain(|&item| item != item_index);2552 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2553 }2554 }25552556 Ok(())2557 }25582559 fn move_token_index(2560 collection_id: CollectionId,2561 item_index: TokenId,2562 old_owner: &T::AccountId,2563 new_owner: &T::AccountId,2564 ) -> DispatchResult {2565 Self::remove_token_index(collection_id, item_index, old_owner)?;2566 Self::add_token_index(collection_id, item_index, new_owner)?;25672568 Ok(())2569 }2570 2571 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2572 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25732574 Ok(())2575 }2576}2577257825792580258125822583pub type Multiplier = FixedU128;25842585type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2586258725882589#[derive(Encode, Decode, Clone, Eq, PartialEq)]2590pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25912592impl<T: Config + Send + Sync> sp_std::fmt::Debug 2593 for ChargeTransactionPayment<T>2594{2595 #[cfg(feature = "std")]2596 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2597 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2598 }2599 #[cfg(not(feature = "std"))]2600 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2601 Ok(())2602 }2603}26042605impl<T: Config> ChargeTransactionPayment<T>2606where2607 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2608 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2609 T::AccountId: AsRef<[u8]>,2610 T::AccountId: UncheckedFrom<T::Hash>,2611{2612 fn traditional_fee(2613 len: usize,2614 info: &DispatchInfoOf<T::Call>,2615 tip: BalanceOf<T>,2616 ) -> BalanceOf<T>2617 where2618 T::Call: Dispatchable<Info = DispatchInfo>,2619 {2620 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2621 }26222623 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2624 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2625 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2626 let len_saturation = max_block_length as u64 / (len as u64).max(1);2627 let coefficient: BalanceOf<T> = weight_saturation2628 .min(len_saturation)2629 .saturated_into::<BalanceOf<T>>();2630 final_fee2631 .saturating_mul(coefficient)2632 .saturated_into::<TransactionPriority>()2633 }26342635 fn withdraw_fee(2636 &self,2637 who: &T::AccountId,2638 call: &T::Call,2639 info: &DispatchInfoOf<T::Call>,2640 len: usize,2641 ) -> Result<2642 (2643 BalanceOf<T>,2644 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2645 ),2646 TransactionValidityError,2647 > {2648 let tip = self.0;26492650 let fee = Self::traditional_fee(len, info, tip);26512652 2653 if fee.is_zero() {2654 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2655 .map(|i| (fee, i));2656 }26572658 2659 2660 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2661 Some(Call::create_item(collection_id, _owner, _properties)) => {2662 let collection = <CollectionById<T>>::get(collection_id)?;26632664 2665 let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;26662667 let limit = collection.limits.sponsor_transfer_timeout;2668 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2669 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2670 let limit_time = last_tx_block + limit.into();2671 if block_number <= limit_time {2672 return None;2673 }2674 }2675 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26762677 2678 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2679 collection.sponsorship.sponsor()2680 .cloned()2681 } else {2682 None2683 }2684 }2685 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2686 let collection = <CollectionById<T>>::get(collection_id)?;2687 2688 let mut sponsor_transfer = false;2689 if collection.sponsorship.confirmed() {26902691 let collection_limits = collection.limits;2692 let collection_mode = collection.mode;2693 2694 2695 let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2696 sponsor_transfer = match collection_mode {2697 CollectionMode::NFT => {2698 2699 2700 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2701 collection_limits.sponsor_transfer_timeout2702 } else {2703 ChainLimit::get().nft_sponsor_transfer_timeout2704 };2705 2706 let mut sponsored = true;2707 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2708 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2709 let limit_time = last_tx_block + limit.into();2710 if block_number <= limit_time {2711 sponsored = false;2712 }2713 }2714 if sponsored {2715 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2716 }27172718 sponsored2719 }2720 CollectionMode::Fungible(_) => {2721 2722 2723 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2724 collection_limits.sponsor_transfer_timeout2725 } else {2726 ChainLimit::get().fungible_sponsor_transfer_timeout2727 };2728 2729 let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2730 let mut sponsored = true;2731 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2732 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2733 let limit_time = last_tx_block + limit.into();2734 if block_number <= limit_time {2735 sponsored = false;2736 }2737 }2738 if sponsored {2739 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2740 }27412742 sponsored2743 }2744 CollectionMode::ReFungible => {2745 2746 2747 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2748 collection_limits.sponsor_transfer_timeout2749 } else {2750 ChainLimit::get().refungible_sponsor_transfer_timeout2751 };2752 2753 let mut sponsored = true;2754 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2755 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2756 let limit_time = last_tx_block + limit.into();2757 if block_number <= limit_time {2758 sponsored = false;2759 }2760 }2761 if sponsored {2762 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2763 }27642765 sponsored2766 }2767 _ => {2768 false2769 },2770 };2771 }27722773 if !sponsor_transfer {2774 None2775 } else {2776 collection.sponsorship.sponsor()2777 .cloned()2778 }2779 }27802781 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2782 let mut sponsor_metadata_changes = false;27832784 let collection = <CollectionById<T>>::get(collection_id)?;27852786 if2787 collection.sponsorship.confirmed() &&2788 2789 2790 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2791 data.len() <= collection.limits.sponsored_data_size as usize2792 {2793 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2794 let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;27952796 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2797 .map(|last_block| block_number - last_block > rate_limit)2798 .unwrap_or(true) 2799 {2800 sponsor_metadata_changes = true;2801 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2802 }2803 }2804 }28052806 if !sponsor_metadata_changes {2807 None2808 } else {2809 collection.sponsorship.sponsor().cloned()2810 }2811 }28122813 _ => None,2814 })();28152816 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2817 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28182819 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28202821 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2822 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2823 2824 if !owned_contract && white_list_enabled {2825 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2826 return Err(InvalidTransaction::Call.into());2827 }2828 }2829 },2830 _ => {},2831 }28322833 2834 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28352836 2837 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28382839 let new_contract_address = <pallet_contracts::Pallet<T>>::contract_address(2840 &who,2841 code_hash,2842 salt,2843 );2844 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28452846 None2847 },28482849 2850 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28512852 let new_contract_address = <pallet_contracts::Pallet<T>>::contract_address(2853 &who,2854 &T::Hashing::hash(&_code),2855 _salt,2856 );28572858 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28592860 None2861 }28622863 2864 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28652866 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28672868 let mut sponsor_transfer = false;2869 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2870 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2871 let block_number = <system::Pallet<T>>::block_number() as T::BlockNumber;2872 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2873 let limit_time = last_tx_block + rate_limit;28742875 if block_number >= limit_time {2876 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2877 sponsor_transfer = true;2878 }2879 } else {2880 sponsor_transfer = false;2881 }2882 2883 if sponsor_transfer {2884 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2885 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2886 return Some(called_contract);2887 }2888 }2889 }28902891 None2892 },28932894 _ => None,2895 });28962897 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28982899 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2900 .map(|i| (fee, i))2901 }2902}290329042905impl<T: Config + Send + Sync> SignedExtension2906 for ChargeTransactionPayment<T>2907where2908 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2909 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2910 T::AccountId: AsRef<[u8]>,2911 T::AccountId: UncheckedFrom<T::Hash>,2912{2913 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2914 type AccountId = T::AccountId;2915 type Call = T::Call;2916 type AdditionalSigned = ();2917 type Pre = (2918 2919 BalanceOf<T>,2920 2921 Self::AccountId,2922 2923 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2924 );2925 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2926 Ok(())2927 }29282929 fn validate(2930 &self,2931 who: &Self::AccountId,2932 call: &Self::Call,2933 info: &DispatchInfoOf<Self::Call>,2934 len: usize,2935 ) -> TransactionValidity {2936 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2937 Ok(ValidTransaction {2938 priority: Self::get_priority(len, info, fee),2939 ..Default::default()2940 })2941 }29422943 fn pre_dispatch(2944 self,2945 who: &Self::AccountId,2946 call: &Self::Call,2947 info: &DispatchInfoOf<Self::Call>,2948 len: usize,2949 ) -> Result<Self::Pre, TransactionValidityError> {2950 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2951 Ok((self.0, who.clone(), imbalance))2952 }29532954 fn post_dispatch(2955 pre: Self::Pre,2956 info: &DispatchInfoOf<Self::Call>,2957 post_info: &PostDispatchInfoOf<Self::Call>,2958 len: usize,2959 _result: &DispatchResult,2960 ) -> Result<(), TransactionValidityError> {2961 let (tip, who, imbalance) = pre;2962 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2963 len as u32,2964 info,2965 post_info,2966 tip,2967 );2968 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2969 Ok(())2970 }2971}29722973