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 collection = Self::get_collection(collection_id)?;12631264 Self::approve_internal(sender, spender, &collection, item_id, amount)?;12651266 Ok(())1267 }1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 #[weight = <T as Config>::WeightInfo::transfer_from()]1289 #[transactional]1290 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12911292 let sender = ensure_signed(origin)?;1293 let collection = Self::get_collection(collection_id)?;12941295 Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;12961297 Ok(())1298 }12991300 1301 13021303 1304 1305 1306 13071308 13091310 13111312 1313 13141315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1328 #[transactional]1329 pub fn set_variable_meta_data (1330 origin,1331 collection_id: CollectionId,1332 item_id: TokenId,1333 data: Vec<u8>1334 ) -> DispatchResult {1335 let sender = ensure_signed(origin)?;1336 1337 let collection = Self::get_collection(collection_id)?;13381339 Self::set_variable_meta_data_internal(sender, &collection, item_id, data)?;13401341 Ok(())1342 }1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 #[weight = <T as Config>::WeightInfo::set_schema_version()]1359 #[transactional]1360 pub fn set_schema_version(1361 origin,1362 collection_id: CollectionId,1363 version: SchemaVersion1364 ) -> DispatchResult {1365 let sender = ensure_signed(origin)?;1366 let mut target_collection = Self::get_collection(collection_id)?;1367 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1368 target_collection.schema_version = version;1369 Self::save_collection(target_collection);13701371 Ok(())1372 }13731374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1387 #[transactional]1388 pub fn set_offchain_schema(1389 origin,1390 collection_id: CollectionId,1391 schema: Vec<u8>1392 ) -> DispatchResult {1393 let sender = ensure_signed(origin)?;1394 let mut target_collection = Self::get_collection(collection_id)?;1395 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;13961397 1398 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13991400 target_collection.offchain_schema = schema;1401 Self::save_collection(target_collection);14021403 Ok(())1404 }14051406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1419 #[transactional]1420 pub fn set_const_on_chain_schema (1421 origin,1422 collection_id: CollectionId,1423 schema: Vec<u8>1424 ) -> DispatchResult {1425 let sender = ensure_signed(origin)?;1426 let mut target_collection = Self::get_collection(collection_id)?;1427 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14281429 1430 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14311432 target_collection.const_on_chain_schema = schema;1433 Self::save_collection(target_collection);14341435 Ok(())1436 }14371438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1451 #[transactional]1452 pub fn set_variable_on_chain_schema (1453 origin,1454 collection_id: CollectionId,1455 schema: Vec<u8>1456 ) -> DispatchResult {1457 let sender = ensure_signed(origin)?;1458 let mut target_collection = Self::get_collection(collection_id)?;1459 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14601461 1462 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14631464 target_collection.variable_on_chain_schema = schema;1465 Self::save_collection(target_collection);14661467 Ok(())1468 }14691470 1471 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1472 #[transactional]1473 pub fn set_chain_limits(1474 origin,1475 limits: ChainLimits1476 ) -> DispatchResult {14771478 #[cfg(not(feature = "runtime-benchmarks"))]1479 ensure_root(origin)?;14801481 <ChainLimit>::put(limits);1482 Ok(())1483 }14841485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1497 #[transactional]1498 pub fn enable_contract_sponsoring(1499 origin,1500 contract_address: T::AccountId,1501 enable: bool1502 ) -> DispatchResult {15031504 let sender = ensure_signed(origin)?;15051506 #[cfg(feature = "runtime-benchmarks")]1507 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15081509 Self::ensure_contract_owned(sender, &contract_address)?;15101511 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1512 Ok(())1513 }15141515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1533 #[transactional]1534 pub fn set_contract_sponsoring_rate_limit(1535 origin,1536 contract_address: T::AccountId,1537 rate_limit: T::BlockNumber1538 ) -> DispatchResult {1539 let sender = ensure_signed(origin)?;15401541 #[cfg(feature = "runtime-benchmarks")]1542 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15431544 Self::ensure_contract_owned(sender, &contract_address)?;1545 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1546 Ok(())1547 }15481549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1561 #[transactional]1562 pub fn toggle_contract_white_list(1563 origin,1564 contract_address: T::AccountId,1565 enable: bool1566 ) -> DispatchResult {1567 let sender = ensure_signed(origin)?;15681569 #[cfg(feature = "runtime-benchmarks")]1570 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15711572 Self::ensure_contract_owned(sender, &contract_address)?;1573 if enable {1574 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1575 } else {1576 <ContractWhiteListEnabled<T>>::remove(contract_address);1577 }1578 Ok(())1579 }1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1593 #[transactional]1594 pub fn add_to_contract_white_list(1595 origin,1596 contract_address: T::AccountId,1597 account_address: T::AccountId1598 ) -> DispatchResult {1599 let sender = ensure_signed(origin)?;16001601 #[cfg(feature = "runtime-benchmarks")]1602 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1603 1604 Self::ensure_contract_owned(sender, &contract_address)?; 1605 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1606 Ok(())1607 }16081609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1621 #[transactional]1622 pub fn remove_from_contract_white_list(1623 origin,1624 contract_address: T::AccountId,1625 account_address: T::AccountId1626 ) -> DispatchResult {1627 let sender = ensure_signed(origin)?;16281629 #[cfg(feature = "runtime-benchmarks")]1630 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16311632 Self::ensure_contract_owned(sender, &contract_address)?;1633 <ContractWhiteList<T>>::remove(contract_address, account_address);1634 Ok(())1635 }16361637 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1638 #[transactional]1639 pub fn set_collection_limits(1640 origin,1641 collection_id: u32,1642 new_limits: CollectionLimits<T::BlockNumber>,1643 ) -> DispatchResult {1644 let sender = ensure_signed(origin)?;1645 let mut target_collection = Self::get_collection(collection_id)?;1646 Self::check_owner_permissions(&target_collection, sender.clone())?;1647 let old_limits = &target_collection.limits;1648 let chain_limits = ChainLimit::get();16491650 1651 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1652 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1653 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1654 Error::<T>::CollectionLimitBoundsExceeded);16551656 1657 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1658 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16591660 ensure!(1661 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1662 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1663 Error::<T>::OwnerPermissionsCantBeReverted,1664 );16651666 target_collection.limits = new_limits;1667 Self::save_collection(target_collection);16681669 Ok(())1670 } 1671 }1672}16731674impl<T: Config> Module<T> {1675 pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1676 let target_collection = Self::get_collection(collection_id)?;16771678 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1679 Self::validate_create_item_args(&target_collection, &data)?;1680 Self::create_item_no_validation(&target_collection, owner, data)?;16811682 Ok(())1683 }16841685 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1686 1687 Self::is_correct_transfer(target_collection, &recipient)?;16881689 1690 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1691 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1692 Error::<T>::NoPermission);16931694 if target_collection.access == AccessMode::WhiteList {1695 Self::check_white_list(target_collection, &sender)?;1696 Self::check_white_list(target_collection, &recipient)?;1697 }16981699 match target_collection.mode1700 {1701 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1702 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1703 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1704 _ => ()1705 };17061707 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17081709 Ok(())1710 }17111712 pub fn approve_internal(1713 sender: T::AccountId,1714 spender: T::AccountId,1715 collection: &CollectionHandle<T>,1716 item_id: TokenId,1717 amount: u128,1718 ) -> DispatchResult {1719 Self::token_exists(&collection, item_id)?;17201721 1722 let bypasses_limits = collection.limits.owner_can_transfer &&1723 Self::is_owner_or_admin_permissions(1724 &collection,1725 sender.clone(),1726 );17271728 let allowance_limit = if bypasses_limits {1729 None1730 } else if let Some(amount) = Self::owned_amount(1731 sender.clone(),1732 &collection,1733 item_id,1734 ) {1735 Some(amount)1736 } else {1737 fail!(Error::<T>::NoPermission);1738 };17391740 if collection.access == AccessMode::WhiteList {1741 Self::check_white_list(&collection, &sender)?;1742 Self::check_white_list(&collection, &spender)?;1743 }17441745 let allowance: u128 = amount1746 .checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1747 .ok_or(Error::<T>::NumOverflow)?;1748 if let Some(limit) = allowance_limit {1749 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1750 }1751 <Allowances<T>>::insert(collection.id, (item_id, &sender, &spender), allowance);17521753 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1754 Ok(())1755 }17561757 pub fn transfer_from_internal(1758 sender: T::AccountId,1759 from: T::AccountId,1760 recipient: T::AccountId,1761 collection: &CollectionHandle<T>,1762 item_id: TokenId,1763 amount: u128,1764 ) -> DispatchResult {1765 1766 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));17671768 1769 Self::is_correct_transfer(&collection, &recipient)?;17701771 1772 ensure!(1773 approval >= amount || 1774 (1775 collection.limits.owner_can_transfer &&1776 Self::is_owner_or_admin_permissions(&collection, sender.clone())1777 ),1778 Error::<T>::NoPermission1779 );17801781 if collection.access == AccessMode::WhiteList {1782 Self::check_white_list(&collection, &sender)?;1783 Self::check_white_list(&collection, &recipient)?;1784 }17851786 1787 let allowance = approval.saturating_sub(amount);1788 if allowance > 0 {1789 <Allowances<T>>::insert(collection.id, (item_id, &from, &sender), allowance);1790 } else {1791 <Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1792 }17931794 match collection.mode {1795 CollectionMode::NFT => {1796 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1797 }1798 CollectionMode::Fungible(_) => {1799 Self::transfer_fungible(&collection, amount, &from, &recipient)?1800 }1801 CollectionMode::ReFungible => {1802 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1803 }1804 _ => ()1805 };18061807 Ok(())1808 }18091810 pub fn set_variable_meta_data_internal(1811 sender: T::AccountId,1812 collection: &CollectionHandle<T>, 1813 item_id: TokenId,1814 data: Vec<u8>,1815 ) -> DispatchResult {1816 Self::token_exists(&collection, item_id)?;18171818 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18191820 1821 ensure!(Self::is_item_owner(sender.clone(), &collection, item_id) ||1822 Self::is_owner_or_admin_permissions(&collection, sender.clone()),1823 Error::<T>::NoPermission);18241825 match collection.mode1826 {1827 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1828 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1829 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1830 _ => fail!(Error::<T>::UnexpectedCollectionType)1831 };18321833 Ok(())1834 }18351836 pub fn create_multiple_items_internal(1837 sender: T::AccountId,1838 collection: &CollectionHandle<T>,1839 owner: T::AccountId,1840 items_data: Vec<CreateItemData>,1841 ) -> DispatchResult {1842 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18431844 for data in &items_data {1845 Self::validate_create_item_args(&collection, data)?;1846 }1847 for data in &items_data {1848 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1849 }18501851 Ok(())1852 }18531854 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1855 let collection_id = collection.id;18561857 1858 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1859 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1860 1861 Ok(())1862 }18631864 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1865 let collection_id = collection.id;18661867 1868 let total_items: u32 = ItemListIndex::get(collection_id)1869 .checked_add(amount)1870 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1871 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1872 .checked_add(amount)1873 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1874 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1875 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18761877 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1878 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1879 Self::check_white_list(collection, owner)?;1880 Self::check_white_list(collection, sender)?;1881 }18821883 Ok(())1884 }18851886 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1887 match target_collection.mode1888 {1889 CollectionMode::NFT => {1890 if let CreateItemData::NFT(data) = data {1891 1892 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1893 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1894 } else {1895 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1896 }1897 },1898 CollectionMode::Fungible(_) => {1899 if let CreateItemData::Fungible(_) = data {1900 } else {1901 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1902 }1903 },1904 CollectionMode::ReFungible => {1905 if let CreateItemData::ReFungible(data) = data {19061907 1908 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1909 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19101911 1912 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1913 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1914 } else {1915 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1916 }1917 },1918 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1919 };19201921 Ok(())1922 }19231924 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1925 match data1926 {1927 CreateItemData::NFT(data) => {1928 let item = NftItemType {1929 owner: owner.clone(),1930 const_data: data.const_data,1931 variable_data: data.variable_data1932 };19331934 Self::add_nft_item(collection, item)?;1935 },1936 CreateItemData::Fungible(data) => {1937 Self::add_fungible_item(collection, &owner, data.value)?;1938 },1939 CreateItemData::ReFungible(data) => {1940 let mut owner_list = Vec::new();1941 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19421943 let item = ReFungibleItemType {1944 owner: owner_list,1945 const_data: data.const_data,1946 variable_data: data.variable_data1947 };19481949 Self::add_refungible_item(collection, item)?;1950 }1951 };19521953 Ok(())1954 }19551956 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1957 let collection_id = collection.id;19581959 1960 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19611962 1963 let item = FungibleItemType {1964 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1965 };1966 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19671968 1969 let new_balance = <Balance<T>>::get(collection_id, owner)1970 .checked_add(value)1971 .ok_or(Error::<T>::NumOverflow)?;1972 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19731974 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1975 Ok(())1976 }19771978 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1979 let collection_id = collection.id;19801981 let current_index = <ItemListIndex>::get(collection_id)1982 .checked_add(1)1983 .ok_or(Error::<T>::NumOverflow)?;1984 let itemcopy = item.clone();19851986 ensure!(1987 item.owner.len() == 1,1988 Error::<T>::BadCreateRefungibleCall,1989 );1990 let item_owner = item.owner.first().expect("only one owner is defined");19911992 let value = item_owner.fraction;1993 let owner = item_owner.owner.clone();19941995 Self::add_token_index(collection_id, current_index, &owner)?;19961997 <ItemListIndex>::insert(collection_id, current_index);1998 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19992000 2001 let new_balance = <Balance<T>>::get(collection_id, &owner)2002 .checked_add(value)2003 .ok_or(Error::<T>::NumOverflow)?;2004 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);20052006 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2007 Ok(())2008 }20092010 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {2011 let collection_id = collection.id;20122013 let current_index = <ItemListIndex>::get(collection_id)2014 .checked_add(1)2015 .ok_or(Error::<T>::NumOverflow)?;20162017 let item_owner = item.owner.clone();2018 Self::add_token_index(collection_id, current_index, &item.owner)?;20192020 <ItemListIndex>::insert(collection_id, current_index);2021 <NftItemList<T>>::insert(collection_id, current_index, item);20222023 2024 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2025 .checked_add(1)2026 .ok_or(Error::<T>::NumOverflow)?;2027 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);20282029 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2030 Ok(())2031 }20322033 fn burn_refungible_item(2034 collection: &CollectionHandle<T>,2035 item_id: TokenId,2036 owner: &T::AccountId,2037 ) -> DispatchResult {2038 let collection_id = collection.id;20392040 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2041 .ok_or(Error::<T>::TokenNotFound)?;2042 let rft_balance = token2043 .owner2044 .iter()2045 .find(|&i| i.owner == *owner)2046 .ok_or(Error::<T>::TokenNotFound)?;2047 Self::remove_token_index(collection_id, item_id, owner)?;20482049 2050 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2051 .checked_sub(rft_balance.fraction)2052 .ok_or(Error::<T>::NumOverflow)?;2053 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20542055 2056 let index = token2057 .owner2058 .iter()2059 .position(|i| i.owner == *owner)2060 .expect("owned item is exists");2061 token.owner.remove(index);2062 let owner_count = token.owner.len();20632064 2065 if owner_count == 0 {2066 <ReFungibleItemList<T>>::remove(collection_id, item_id);2067 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2068 }2069 else {2070 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2071 }20722073 Ok(())2074 }20752076 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2077 let collection_id = collection.id;20782079 let item = <NftItemList<T>>::get(collection_id, item_id)2080 .ok_or(Error::<T>::TokenNotFound)?;2081 Self::remove_token_index(collection_id, item_id, &item.owner)?;20822083 2084 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2085 .checked_sub(1)2086 .ok_or(Error::<T>::NumOverflow)?;2087 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2088 <NftItemList<T>>::remove(collection_id, item_id);2089 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20902091 Ok(())2092 }20932094 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2095 let collection_id = collection.id;20962097 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2098 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20992100 2101 let new_balance = <Balance<T>>::get(collection_id, owner)2102 .checked_sub(value)2103 .ok_or(Error::<T>::NumOverflow)?;2104 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);21052106 if balance.value - value > 0 {2107 balance.value -= value;2108 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2109 }2110 else {2111 <FungibleItemList<T>>::remove(collection_id, owner);2112 }21132114 Ok(())2115 }21162117 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2118 Ok(<CollectionById<T>>::get(collection_id)2119 .map(|collection| CollectionHandle {2120 id: collection_id,2121 collection2122 })2123 .ok_or(Error::<T>::CollectionNotFound)?)2124 }21252126 fn save_collection(collection: CollectionHandle<T>) {2127 <CollectionById<T>>::insert(collection.id, collection.collection);2128 }21292130 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2131 ensure!(2132 subject == target_collection.owner,2133 Error::<T>::NoPermission2134 );21352136 Ok(())2137 }21382139 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2140 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2141 }21422143 fn check_owner_or_admin_permissions(2144 collection: &CollectionHandle<T>,2145 subject: T::AccountId,2146 ) -> DispatchResult {2147 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21482149 Ok(())2150 }21512152 fn owned_amount(2153 subject: T::AccountId,2154 target_collection: &CollectionHandle<T>,2155 item_id: TokenId,2156 ) -> Option<u128> {2157 let collection_id = target_collection.id;21582159 match target_collection.mode {2160 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2161 .then(|| 1),2162 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2163 .value),2164 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2165 .owner2166 .iter()2167 .find(|i| i.owner == subject)2168 .map(|i| i.fraction),2169 CollectionMode::Invalid => None,2170 }2171 }21722173 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2174 match target_collection.mode {2175 CollectionMode::Fungible(_) => true,2176 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2177 }2178 }21792180 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2181 let collection_id = collection.id;21822183 let mes = Error::<T>::AddresNotInWhiteList;2184 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21852186 Ok(())2187 }21882189 2190 2191 fn token_exists(2192 target_collection: &CollectionHandle<T>,2193 item_id: TokenId,2194 ) -> DispatchResult {2195 let collection_id = target_collection.id;2196 let exists = match target_collection.mode2197 {2198 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2199 CollectionMode::Fungible(_) => true,2200 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2201 _ => false2202 };22032204 ensure!(exists == true, Error::<T>::TokenNotFound);2205 Ok(())2206 }22072208 fn transfer_fungible(2209 collection: &CollectionHandle<T>,2210 value: u128,2211 owner: &T::AccountId,2212 recipient: &T::AccountId,2213 ) -> DispatchResult {2214 let collection_id = collection.id;22152216 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2217 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22182219 2220 Self::add_fungible_item(collection, recipient, value)?;22212222 2223 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22242225 2226 if balance.value == value {2227 <FungibleItemList<T>>::remove(collection_id, owner);2228 }2229 else {2230 balance.value -= value;2231 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2232 }22332234 Ok(())2235 }22362237 fn transfer_refungible(2238 collection: &CollectionHandle<T>,2239 item_id: TokenId,2240 value: u128,2241 owner: T::AccountId,2242 new_owner: T::AccountId,2243 ) -> DispatchResult {2244 let collection_id = collection.id;2245 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2246 .ok_or(Error::<T>::TokenNotFound)?;22472248 let item = full_item2249 .owner2250 .iter()2251 .filter(|i| i.owner == owner)2252 .next()2253 .ok_or(Error::<T>::TokenNotFound)?;2254 let amount = item.fraction;22552256 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22572258 2259 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2260 .checked_sub(value)2261 .ok_or(Error::<T>::NumOverflow)?;2262 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22632264 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2265 .checked_add(value)2266 .ok_or(Error::<T>::NumOverflow)?;2267 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22682269 let old_owner = item.owner.clone();2270 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22712272 2273 if amount == value && !new_owner_has_account {2274 2275 2276 let mut new_full_item = full_item.clone();2277 new_full_item2278 .owner2279 .iter_mut()2280 .find(|i| i.owner == owner)2281 .expect("old owner does present in refungible")2282 .owner = new_owner.clone();2283 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22842285 2286 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2287 } else {2288 let mut new_full_item = full_item.clone();2289 new_full_item2290 .owner2291 .iter_mut()2292 .find(|i| i.owner == owner)2293 .expect("old owner does present in refungible")2294 .fraction -= value;22952296 2297 if new_owner_has_account {2298 2299 new_full_item2300 .owner2301 .iter_mut()2302 .find(|i| i.owner == new_owner)2303 .expect("new owner has account")2304 .fraction += value;2305 } else {2306 2307 new_full_item.owner.push(Ownership {2308 owner: new_owner.clone(),2309 fraction: value,2310 });2311 Self::add_token_index(collection_id, item_id, &new_owner)?;2312 }23132314 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2315 }23162317 Ok(())2318 }23192320 fn transfer_nft(2321 collection: &CollectionHandle<T>,2322 item_id: TokenId,2323 sender: T::AccountId,2324 new_owner: T::AccountId,2325 ) -> DispatchResult {2326 let collection_id = collection.id;2327 let mut item = <NftItemList<T>>::get(collection_id, item_id)2328 .ok_or(Error::<T>::TokenNotFound)?;23292330 ensure!(2331 sender == item.owner,2332 Error::<T>::MustBeTokenOwner2333 );23342335 2336 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2337 .checked_sub(1)2338 .ok_or(Error::<T>::NumOverflow)?;2339 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23402341 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2342 .checked_add(1)2343 .ok_or(Error::<T>::NumOverflow)?;2344 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23452346 2347 let old_owner = item.owner.clone();2348 item.owner = new_owner.clone();2349 <NftItemList<T>>::insert(collection_id, item_id, item);23502351 2352 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23532354 Ok(())2355 }2356 2357 fn set_re_fungible_variable_data(2358 collection: &CollectionHandle<T>,2359 item_id: TokenId,2360 data: Vec<u8>2361 ) -> DispatchResult {2362 let collection_id = collection.id;2363 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2364 .ok_or(Error::<T>::TokenNotFound)?;23652366 item.variable_data = data;23672368 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23692370 Ok(())2371 }23722373 fn set_nft_variable_data(2374 collection: &CollectionHandle<T>,2375 item_id: TokenId,2376 data: Vec<u8>2377 ) -> DispatchResult {2378 let collection_id = collection.id;2379 let mut item = <NftItemList<T>>::get(collection_id, item_id)2380 .ok_or(Error::<T>::TokenNotFound)?;2381 2382 item.variable_data = data;23832384 <NftItemList<T>>::insert(collection_id, item_id, item);2385 2386 Ok(())2387 }23882389 fn init_collection(item: &Collection<T>) {2390 2391 assert!(2392 item.decimal_points <= MAX_DECIMAL_POINTS,2393 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2394 );2395 assert!(2396 item.name.len() <= 64,2397 "Collection name can not be longer than 63 char"2398 );2399 assert!(2400 item.name.len() <= 256,2401 "Collection description can not be longer than 255 char"2402 );2403 assert!(2404 item.token_prefix.len() <= 16,2405 "Token prefix can not be longer than 15 char"2406 );24072408 2409 let next_id = CreatedCollectionCount::get()2410 .checked_add(1)2411 .unwrap();24122413 CreatedCollectionCount::put(next_id);2414 }24152416 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2417 let current_index = <ItemListIndex>::get(collection_id)2418 .checked_add(1)2419 .unwrap();24202421 let item_owner = item.owner.clone();2422 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24232424 <ItemListIndex>::insert(collection_id, current_index);24252426 2427 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2428 .checked_add(1)2429 .unwrap();2430 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2431 }24322433 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2434 let current_index = <ItemListIndex>::get(collection_id)2435 .checked_add(1)2436 .unwrap();24372438 Self::add_token_index(collection_id, current_index, owner).unwrap();24392440 <ItemListIndex>::insert(collection_id, current_index);24412442 2443 let new_balance = <Balance<T>>::get(collection_id, owner)2444 .checked_add(item.value)2445 .unwrap();2446 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2447 }24482449 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2450 let current_index = <ItemListIndex>::get(collection_id)2451 .checked_add(1)2452 .unwrap();24532454 let value = item.owner.first().unwrap().fraction;2455 let owner = item.owner.first().unwrap().owner.clone();24562457 Self::add_token_index(collection_id, current_index, &owner).unwrap();24582459 <ItemListIndex>::insert(collection_id, current_index);24602461 2462 let new_balance = <Balance<T>>::get(collection_id, &owner)2463 .checked_add(value)2464 .unwrap();2465 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2466 }24672468 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2469 2470 if <AccountItemCount<T>>::contains_key(owner) {24712472 2473 let count = <AccountItemCount<T>>::get(owner);2474 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24752476 <AccountItemCount<T>>::insert(owner.clone(), count2477 .checked_add(1)2478 .ok_or(Error::<T>::NumOverflow)?);2479 }2480 else {2481 <AccountItemCount<T>>::insert(owner.clone(), 1);2482 }24832484 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2485 if list_exists {2486 let mut list = <AddressTokens<T>>::get(collection_id, owner);2487 let item_contains = list.contains(&item_index.clone());24882489 if !item_contains {2490 list.push(item_index.clone());2491 }24922493 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2494 } else {2495 let mut itm = Vec::new();2496 itm.push(item_index.clone());2497 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2498 }24992500 Ok(())2501 }25022503 fn remove_token_index(2504 collection_id: CollectionId,2505 item_index: TokenId,2506 owner: &T::AccountId,2507 ) -> DispatchResult {25082509 2510 <AccountItemCount<T>>::insert(owner.clone(), 2511 <AccountItemCount<T>>::get(owner)2512 .checked_sub(1)2513 .ok_or(Error::<T>::NumOverflow)?);251425152516 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2517 if list_exists {2518 let mut list = <AddressTokens<T>>::get(collection_id, owner);2519 let item_contains = list.contains(&item_index.clone());25202521 if item_contains {2522 list.retain(|&item| item != item_index);2523 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2524 }2525 }25262527 Ok(())2528 }25292530 fn move_token_index(2531 collection_id: CollectionId,2532 item_index: TokenId,2533 old_owner: &T::AccountId,2534 new_owner: &T::AccountId,2535 ) -> DispatchResult {2536 Self::remove_token_index(collection_id, item_index, old_owner)?;2537 Self::add_token_index(collection_id, item_index, new_owner)?;25382539 Ok(())2540 }2541 2542 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2543 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25442545 Ok(())2546 }2547}2548254925502551255225532554pub type Multiplier = FixedU128;25552556type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2557255825592560#[derive(Encode, Decode, Clone, Eq, PartialEq)]2561pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25622563impl<T: Config + Send + Sync> sp_std::fmt::Debug 2564 for ChargeTransactionPayment<T>2565{2566 #[cfg(feature = "std")]2567 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2568 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2569 }2570 #[cfg(not(feature = "std"))]2571 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2572 Ok(())2573 }2574}25752576impl<T: Config> ChargeTransactionPayment<T>2577where2578 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2579 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2580 T::AccountId: AsRef<[u8]>,2581 T::AccountId: UncheckedFrom<T::Hash>,2582{2583 fn traditional_fee(2584 len: usize,2585 info: &DispatchInfoOf<T::Call>,2586 tip: BalanceOf<T>,2587 ) -> BalanceOf<T>2588 where2589 T::Call: Dispatchable<Info = DispatchInfo>,2590 {2591 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2592 }25932594 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2595 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2596 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2597 let len_saturation = max_block_length as u64 / (len as u64).max(1);2598 let coefficient: BalanceOf<T> = weight_saturation2599 .min(len_saturation)2600 .saturated_into::<BalanceOf<T>>();2601 final_fee2602 .saturating_mul(coefficient)2603 .saturated_into::<TransactionPriority>()2604 }26052606 fn withdraw_fee(2607 &self,2608 who: &T::AccountId,2609 call: &T::Call,2610 info: &DispatchInfoOf<T::Call>,2611 len: usize,2612 ) -> Result<2613 (2614 BalanceOf<T>,2615 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2616 ),2617 TransactionValidityError,2618 > {2619 let tip = self.0;26202621 let fee = Self::traditional_fee(len, info, tip);26222623 2624 if fee.is_zero() {2625 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2626 .map(|i| (fee, i));2627 }26282629 2630 2631 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2632 Some(Call::create_item(collection_id, _owner, _properties)) => {2633 let collection = <CollectionById<T>>::get(collection_id)?;26342635 2636 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26372638 let limit = collection.limits.sponsor_transfer_timeout;2639 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2640 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2641 let limit_time = last_tx_block + limit.into();2642 if block_number <= limit_time {2643 return None;2644 }2645 }2646 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26472648 2649 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2650 collection.sponsorship.sponsor()2651 .cloned()2652 } else {2653 None2654 }2655 }2656 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2657 let collection = <CollectionById<T>>::get(collection_id)?;2658 2659 let mut sponsor_transfer = false;2660 if collection.sponsorship.confirmed() {26612662 let collection_limits = collection.limits;2663 let collection_mode = collection.mode;2664 2665 2666 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2667 sponsor_transfer = match collection_mode {2668 CollectionMode::NFT => {2669 2670 2671 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2672 collection_limits.sponsor_transfer_timeout2673 } else {2674 ChainLimit::get().nft_sponsor_transfer_timeout2675 };2676 2677 let mut sponsored = true;2678 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2679 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2680 let limit_time = last_tx_block + limit.into();2681 if block_number <= limit_time {2682 sponsored = false;2683 }2684 }2685 if sponsored {2686 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2687 }26882689 sponsored2690 }2691 CollectionMode::Fungible(_) => {2692 2693 2694 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2695 collection_limits.sponsor_transfer_timeout2696 } else {2697 ChainLimit::get().fungible_sponsor_transfer_timeout2698 };2699 2700 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2701 let mut sponsored = true;2702 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2703 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2704 let limit_time = last_tx_block + limit.into();2705 if block_number <= limit_time {2706 sponsored = false;2707 }2708 }2709 if sponsored {2710 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2711 }27122713 sponsored2714 }2715 CollectionMode::ReFungible => {2716 2717 2718 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2719 collection_limits.sponsor_transfer_timeout2720 } else {2721 ChainLimit::get().refungible_sponsor_transfer_timeout2722 };2723 2724 let mut sponsored = true;2725 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2726 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2727 let limit_time = last_tx_block + limit.into();2728 if block_number <= limit_time {2729 sponsored = false;2730 }2731 }2732 if sponsored {2733 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2734 }27352736 sponsored2737 }2738 _ => {2739 false2740 },2741 };2742 }27432744 if !sponsor_transfer {2745 None2746 } else {2747 collection.sponsorship.sponsor()2748 .cloned()2749 }2750 }27512752 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2753 let mut sponsor_metadata_changes = false;27542755 let collection = <CollectionById<T>>::get(collection_id)?;27562757 if2758 collection.sponsorship.confirmed() &&2759 2760 2761 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2762 data.len() <= collection.limits.sponsored_data_size as usize2763 {2764 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2765 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27662767 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2768 .map(|last_block| block_number - last_block > rate_limit)2769 .unwrap_or(true) 2770 {2771 sponsor_metadata_changes = true;2772 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2773 }2774 }2775 }27762777 if !sponsor_metadata_changes {2778 None2779 } else {2780 collection.sponsorship.sponsor().cloned()2781 }2782 }27832784 _ => None,2785 })();27862787 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2788 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27892790 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27912792 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2793 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2794 2795 if !owned_contract && white_list_enabled {2796 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2797 return Err(InvalidTransaction::Call.into());2798 }2799 }2800 },2801 _ => {},2802 }28032804 2805 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28062807 2808 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28092810 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2811 &who,2812 code_hash,2813 salt,2814 );2815 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28162817 None2818 },28192820 2821 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28222823 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2824 &who,2825 &T::Hashing::hash(&_code),2826 _salt,2827 );28282829 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28302831 None2832 }28332834 2835 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28362837 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28382839 let mut sponsor_transfer = false;2840 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2841 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2842 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2843 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2844 let limit_time = last_tx_block + rate_limit;28452846 if block_number >= limit_time {2847 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2848 sponsor_transfer = true;2849 }2850 } else {2851 sponsor_transfer = false;2852 }2853 2854 if sponsor_transfer {2855 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2856 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2857 return Some(called_contract);2858 }2859 }2860 }28612862 None2863 },28642865 _ => None,2866 });28672868 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28692870 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2871 .map(|i| (fee, i))2872 }2873}287428752876impl<T: Config + Send + Sync> SignedExtension2877 for ChargeTransactionPayment<T>2878where2879 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2880 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2881 T::AccountId: AsRef<[u8]>,2882 T::AccountId: UncheckedFrom<T::Hash>,2883{2884 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2885 type AccountId = T::AccountId;2886 type Call = T::Call;2887 type AdditionalSigned = ();2888 type Pre = (2889 2890 BalanceOf<T>,2891 2892 Self::AccountId,2893 2894 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2895 );2896 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2897 Ok(())2898 }28992900 fn validate(2901 &self,2902 who: &Self::AccountId,2903 call: &Self::Call,2904 info: &DispatchInfoOf<Self::Call>,2905 len: usize,2906 ) -> TransactionValidity {2907 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2908 Ok(ValidTransaction {2909 priority: Self::get_priority(len, info, fee),2910 ..Default::default()2911 })2912 }29132914 fn pre_dispatch(2915 self,2916 who: &Self::AccountId,2917 call: &Self::Call,2918 info: &DispatchInfoOf<Self::Call>,2919 len: usize,2920 ) -> Result<Self::Pre, TransactionValidityError> {2921 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2922 Ok((self.0, who.clone(), imbalance))2923 }29242925 fn post_dispatch(2926 pre: Self::Pre,2927 info: &DispatchInfoOf<Self::Call>,2928 post_info: &PostDispatchInfoOf<Self::Call>,2929 len: usize,2930 _result: &DispatchResult,2931 ) -> Result<(), TransactionValidityError> {2932 let (tip, who, imbalance) = pre;2933 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2934 len as u32,2935 info,2936 post_info,2937 tip,2938 );2939 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2940 Ok(())2941 }2942}29432944