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<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, Default, 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, Default, 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 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;541542 543 544 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;545 546 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;547 548 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;549 550551 552 553 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;554 555556 557 558 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;559 560 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;561 562 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;563 564 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;565 566567 568 569 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;570 571 572 573 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;574 575 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;576 577 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;578 579 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;580 581 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 582 583 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 584 585 }586 add_extra_genesis {587 build(|config: &GenesisConfig<T>| {588 589 for (_num, _c) in &config.collection_id {590 <Module<T>>::init_collection(_c);591 }592593 for (_num, _c, _i) in &config.nft_item_id {594 <Module<T>>::init_nft_token(*_c, _i);595 }596597 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {598 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);599 }600601 for (_num, _c, _i) in &config.refungible_item_id {602 <Module<T>>::init_refungible_token(*_c, _i);603 }604 })605 }606}607608decl_event!(609 pub enum Event<T>610 where611 AccountId = <T as system::Config>::AccountId,612 {613 614 615 616 617 618 619 620 621 622 Created(CollectionId, u8, AccountId),623624 625 626 627 628 629 630 631 632 633 ItemCreated(CollectionId, TokenId, AccountId),634635 636 637 638 639 640 641 642 ItemDestroyed(CollectionId, TokenId),643644 645 646 647 648 649 650 651 652 653 654 655 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),656 }657);658659decl_module! {660 pub struct Module<T: Config> for enum Call 661 where 662 origin: T::Origin663 {664 fn deposit_event() = default;665 type Error = Error<T>;666667 fn on_initialize(now: T::BlockNumber) -> Weight {668 0669 }670671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 #[weight = <T as Config>::WeightInfo::create_collection()]688 #[transactional]689 pub fn create_collection(origin,690 collection_name: Vec<u16>,691 collection_description: Vec<u16>,692 token_prefix: Vec<u8>,693 mode: CollectionMode) -> DispatchResult {694695 696 let who = ensure_signed(origin)?;697698 699 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();700 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(701 &T::TreasuryAccountId::get(),702 T::CollectionCreationPrice::get(),703 ));704 <T as Config>::Currency::settle(705 &who,706 imbalance,707 WithdrawReasons::TRANSFER,708 ExistenceRequirement::KeepAlive,709 ).map_err(|_| Error::<T>::NoPermission)?;710711 let decimal_points = match mode {712 CollectionMode::Fungible(points) => points,713 _ => 0714 };715716 let chain_limit = ChainLimit::get();717718 let created_count = CreatedCollectionCount::get();719 let destroyed_count = DestroyedCollectionCount::get();720721 722 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);723724 725 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);726 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);727 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);728 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);729730 731 let next_id = created_count732 .checked_add(1)733 .ok_or(Error::<T>::NumOverflow)?;734735 CreatedCollectionCount::put(next_id);736737 let limits = CollectionLimits {738 sponsored_data_size: chain_limit.custom_data_limit,739 ..Default::default()740 };741742 743 let new_collection = Collection {744 owner: who.clone(),745 name: collection_name,746 mode: mode.clone(),747 mint_mode: false,748 access: AccessMode::Normal,749 description: collection_description,750 decimal_points: decimal_points,751 token_prefix: token_prefix,752 offchain_schema: Vec::new(),753 schema_version: SchemaVersion::ImageURL,754 sponsorship: SponsorshipState::Disabled,755 variable_on_chain_schema: Vec::new(),756 const_on_chain_schema: Vec::new(),757 limits,758 };759760 761 <CollectionById<T>>::insert(next_id, new_collection);762763 764 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));765766 Ok(())767 }768769 770 771 772 773 774 775 776 777 778 #[weight = <T as Config>::WeightInfo::destroy_collection()]779 #[transactional]780 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {781782 let sender = ensure_signed(origin)?;783 let collection = Self::get_collection(collection_id)?;784 Self::check_owner_permissions(&collection, sender)?;785 if !collection.limits.owner_can_destroy {786 fail!(Error::<T>::NoPermission);787 }788789 <AddressTokens<T>>::remove_prefix(collection_id);790 <Allowances<T>>::remove_prefix(collection_id);791 <Balance<T>>::remove_prefix(collection_id);792 <ItemListIndex>::remove(collection_id);793 <AdminList<T>>::remove(collection_id);794 <CollectionById<T>>::remove(collection_id);795 <WhiteList<T>>::remove_prefix(collection_id);796797 <NftItemList<T>>::remove_prefix(collection_id);798 <FungibleItemList<T>>::remove_prefix(collection_id);799 <ReFungibleItemList<T>>::remove_prefix(collection_id);800801 <NftTransferBasket<T>>::remove_prefix(collection_id);802 <FungibleTransferBasket<T>>::remove_prefix(collection_id);803 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);804805 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);806807 DestroyedCollectionCount::put(DestroyedCollectionCount::get()808 .checked_add(1)809 .ok_or(Error::<T>::NumOverflow)?);810811 Ok(())812 }813814 815 816 817 818 819 820 821 822 823 824 825 826 #[weight = <T as Config>::WeightInfo::add_to_white_list()]827 #[transactional]828 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{829830 let sender = ensure_signed(origin)?;831 let collection = Self::get_collection(collection_id)?;832 Self::check_owner_or_admin_permissions(&collection, sender)?;833834 <WhiteList<T>>::insert(collection_id, address, true);835 836 Ok(())837 }838839 840 841 842 843 844 845 846 847 848 849 850 851 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]852 #[transactional]853 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{854855 let sender = ensure_signed(origin)?;856 let collection = Self::get_collection(collection_id)?;857 Self::check_owner_or_admin_permissions(&collection, sender)?;858859 <WhiteList<T>>::remove(collection_id, address);860861 Ok(())862 }863864 865 866 867 868 869 870 871 872 873 874 875 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]876 #[transactional]877 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult878 {879 let sender = ensure_signed(origin)?;880881 let mut target_collection = Self::get_collection(collection_id)?;882 Self::check_owner_permissions(&target_collection, sender)?;883 target_collection.access = mode;884 Self::save_collection(target_collection);885886 Ok(())887 }888889 890 891 892 893 894 895 896 897 898 899 900 901 902 #[weight = <T as Config>::WeightInfo::set_mint_permission()]903 #[transactional]904 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult905 {906 let sender = ensure_signed(origin)?;907908 let mut target_collection = Self::get_collection(collection_id)?;909 Self::check_owner_permissions(&target_collection, sender)?;910 target_collection.mint_mode = mint_permission;911 Self::save_collection(target_collection);912913 Ok(())914 }915916 917 918 919 920 921 922 923 924 925 926 927 #[weight = <T as Config>::WeightInfo::change_collection_owner()]928 #[transactional]929 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {930931 let sender = ensure_signed(origin)?;932 let mut target_collection = Self::get_collection(collection_id)?;933 Self::check_owner_permissions(&target_collection, sender)?;934 target_collection.owner = new_owner;935 Self::save_collection(target_collection);936937 Ok(())938 }939940 941 942 943 944 945 946 947 948 949 950 951 952 953 #[weight = <T as Config>::WeightInfo::add_collection_admin()]954 #[transactional]955 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {956957 let sender = ensure_signed(origin)?;958 let collection = Self::get_collection(collection_id)?;959 Self::check_owner_or_admin_permissions(&collection, sender)?;960 let mut admin_arr: Vec<T::AccountId> = Vec::new();961962 if <AdminList<T>>::contains_key(collection_id)963 {964 admin_arr = <AdminList<T>>::get(collection_id);965 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);966 }967968 969 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);970971 admin_arr.push(new_admin_id);972 <AdminList<T>>::insert(collection_id, admin_arr);973974 Ok(())975 }976977 978 979 980 981 982 983 984 985 986 987 988 989 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]990 #[transactional]991 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {992993 let sender = ensure_signed(origin)?;994 let collection = Self::get_collection(collection_id)?;995 Self::check_owner_or_admin_permissions(&collection, sender)?;996 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);997998 let mut admin_arr = <AdminList<T>>::get(collection_id);999 admin_arr.retain(|i| *i != account_id);1000 <AdminList<T>>::insert(collection_id, admin_arr);10011002 Ok(())1003 }10041005 1006 1007 1008 1009 1010 1011 1012 1013 1014 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1015 #[transactional]1016 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10171018 let sender = ensure_signed(origin)?;1019 let mut target_collection = Self::get_collection(collection_id)?;1020 Self::check_owner_permissions(&target_collection, sender)?;10211022 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1023 Self::save_collection(target_collection);10241025 Ok(())1026 }10271028 1029 1030 1031 1032 1033 1034 1035 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1036 #[transactional]1037 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10381039 let sender = ensure_signed(origin)?;10401041 let mut target_collection = Self::get_collection(collection_id)?;1042 ensure!(1043 target_collection.sponsorship.pending_sponsor() == Some(&sender),1044 Error::<T>::ConfirmUnsetSponsorFail1045 );10461047 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1048 Self::save_collection(target_collection);10491050 Ok(())1051 }10521053 1054 1055 1056 1057 1058 1059 1060 1061 1062 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1063 #[transactional]1064 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10651066 let sender = ensure_signed(origin)?;10671068 let mut target_collection = Self::get_collection(collection_id)?;1069 Self::check_owner_permissions(&target_collection, sender)?;10701071 target_collection.sponsorship = SponsorshipState::Disabled;1072 Self::save_collection(target_collection);10731074 Ok(())1075 }10761077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 11001101 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1102 #[transactional]1103 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11041105 let sender = ensure_signed(origin)?;11061107 let target_collection = Self::get_collection(collection_id)?;11081109 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1110 Self::validate_create_item_args(&target_collection, &data)?;1111 Self::create_item_no_validation(&target_collection, owner, data)?;11121113 Ok(())1114 }11151116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1135 .map(|data| { data.len() })1136 .sum())]1137 #[transactional]1138 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11391140 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1141 let sender = ensure_signed(origin)?;11421143 let target_collection = Self::get_collection(collection_id)?;11441145 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11461147 for data in &items_data {1148 Self::validate_create_item_args(&target_collection, data)?;1149 }1150 for data in &items_data {1151 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1152 }11531154 Ok(())1155 }11561157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 #[weight = <T as Config>::WeightInfo::burn_item()]1171 #[transactional]1172 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11731174 let sender = ensure_signed(origin)?;11751176 1177 let target_collection = Self::get_collection(collection_id)?;1178 ensure!(1179 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1180 (1181 target_collection.limits.owner_can_transfer &&1182 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1183 ),1184 Error::<T>::NoPermission1185 );11861187 if target_collection.access == AccessMode::WhiteList {1188 Self::check_white_list(&target_collection, &sender)?;1189 }11901191 match target_collection.mode1192 {1193 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1194 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1195 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1196 _ => ()1197 };11981199 1200 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12011202 Ok(())1203 }12041205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 #[weight = <T as Config>::WeightInfo::transfer()]1229 #[transactional]1230 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1231 let sender = ensure_signed(origin)?;1232 let collection = Self::get_collection(collection_id)?;12331234 Self::transfer_internal(sender, recipient, &collection, item_id, value)1235 }12361237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 #[weight = <T as Config>::WeightInfo::approve()]1253 #[transactional]1254 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12551256 let sender = ensure_signed(origin)?;1257 let target_collection = Self::get_collection(collection_id)?;12581259 Self::token_exists(&target_collection, item_id, &sender)?;12601261 1262 let bypasses_limits = target_collection.limits.owner_can_transfer &&1263 Self::is_owner_or_admin_permissions(1264 &target_collection,1265 sender.clone(),1266 );12671268 let allowance_limit = if bypasses_limits {1269 None1270 } else if let Some(amount) = Self::owned_amount(1271 sender.clone(),1272 &target_collection,1273 item_id,1274 ) {1275 Some(amount)1276 } else {1277 fail!(Error::<T>::NoPermission);1278 };12791280 if target_collection.access == AccessMode::WhiteList {1281 Self::check_white_list(&target_collection, &sender)?;1282 Self::check_white_list(&target_collection, &spender)?;1283 }12841285 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1286 let mut allowance: u128 = amount;1287 if allowance_exists {1288 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1289 }1290 if let Some(limit) = allowance_limit {1291 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1292 }1293 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12941295 Ok(())1296 }1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 #[weight = <T as Config>::WeightInfo::transfer_from()]1318 #[transactional]1319 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13201321 let sender = ensure_signed(origin)?;1322 let target_collection = Self::get_collection(collection_id)?;13231324 let mut appoved_transfer = false;13251326 1327 let mut approval: u128 = 0;1328 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1329 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1330 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1331 appoved_transfer = true;1332 }13331334 1335 Self::is_correct_transfer(&target_collection, &recipient)?;13361337 1338 ensure!(1339 appoved_transfer || 1340 (1341 target_collection.limits.owner_can_transfer &&1342 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1343 ),1344 Error::<T>::NoPermission1345 );13461347 if target_collection.access == AccessMode::WhiteList {1348 Self::check_white_list(&target_collection, &sender)?;1349 Self::check_white_list(&target_collection, &recipient)?;1350 }13511352 1353 if approval.saturating_sub(value) > 0 {1354 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1355 }1356 else {1357 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1358 }13591360 match target_collection.mode1361 {1362 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1363 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1364 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1365 _ => ()1366 };13671368 Ok(())1369 }13701371 1372 13731374 1375 1376 1377 13781379 13801381 13821383 1384 13851386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1399 #[transactional]1400 pub fn set_variable_meta_data (1401 origin,1402 collection_id: CollectionId,1403 item_id: TokenId,1404 data: Vec<u8>1405 ) -> DispatchResult {1406 let sender = ensure_signed(origin)?;1407 1408 let target_collection = Self::get_collection(collection_id)?;1409 Self::token_exists(&target_collection, item_id, &sender)?;14101411 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14121413 1414 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1415 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1416 Error::<T>::NoPermission);14171418 match target_collection.mode1419 {1420 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1421 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1422 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1423 _ => fail!(Error::<T>::UnexpectedCollectionType)1424 };14251426 Ok(())1427 }1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 #[weight = <T as Config>::WeightInfo::set_schema_version()]1444 #[transactional]1445 pub fn set_schema_version(1446 origin,1447 collection_id: CollectionId,1448 version: SchemaVersion1449 ) -> DispatchResult {1450 let sender = ensure_signed(origin)?;1451 let mut target_collection = Self::get_collection(collection_id)?;1452 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1453 target_collection.schema_version = version;1454 Self::save_collection(target_collection);14551456 Ok(())1457 }14581459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1472 #[transactional]1473 pub fn set_offchain_schema(1474 origin,1475 collection_id: CollectionId,1476 schema: Vec<u8>1477 ) -> DispatchResult {1478 let sender = ensure_signed(origin)?;1479 let mut target_collection = Self::get_collection(collection_id)?;1480 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14811482 1483 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14841485 target_collection.offchain_schema = schema;1486 Self::save_collection(target_collection);14871488 Ok(())1489 }14901491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1504 #[transactional]1505 pub fn set_const_on_chain_schema (1506 origin,1507 collection_id: CollectionId,1508 schema: Vec<u8>1509 ) -> DispatchResult {1510 let sender = ensure_signed(origin)?;1511 let mut target_collection = Self::get_collection(collection_id)?;1512 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15131514 1515 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15161517 target_collection.const_on_chain_schema = schema;1518 Self::save_collection(target_collection);15191520 Ok(())1521 }15221523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1536 #[transactional]1537 pub fn set_variable_on_chain_schema (1538 origin,1539 collection_id: CollectionId,1540 schema: Vec<u8>1541 ) -> DispatchResult {1542 let sender = ensure_signed(origin)?;1543 let mut target_collection = Self::get_collection(collection_id)?;1544 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15451546 1547 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15481549 target_collection.variable_on_chain_schema = schema;1550 Self::save_collection(target_collection);15511552 Ok(())1553 }15541555 1556 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1557 #[transactional]1558 pub fn set_chain_limits(1559 origin,1560 limits: ChainLimits1561 ) -> DispatchResult {15621563 #[cfg(not(feature = "runtime-benchmarks"))]1564 ensure_root(origin)?;15651566 <ChainLimit>::put(limits);1567 Ok(())1568 }15691570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1582 #[transactional]1583 pub fn enable_contract_sponsoring(1584 origin,1585 contract_address: T::AccountId,1586 enable: bool1587 ) -> DispatchResult {15881589 let sender = ensure_signed(origin)?;15901591 #[cfg(feature = "runtime-benchmarks")]1592 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15931594 Self::ensure_contract_owned(sender, &contract_address)?;15951596 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1597 Ok(())1598 }15991600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1618 #[transactional]1619 pub fn set_contract_sponsoring_rate_limit(1620 origin,1621 contract_address: T::AccountId,1622 rate_limit: T::BlockNumber1623 ) -> DispatchResult {1624 let sender = ensure_signed(origin)?;16251626 #[cfg(feature = "runtime-benchmarks")]1627 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16281629 Self::ensure_contract_owned(sender, &contract_address)?;1630 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1631 Ok(())1632 }16331634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1646 #[transactional]1647 pub fn toggle_contract_white_list(1648 origin,1649 contract_address: T::AccountId,1650 enable: bool1651 ) -> DispatchResult {1652 let sender = ensure_signed(origin)?;16531654 #[cfg(feature = "runtime-benchmarks")]1655 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16561657 Self::ensure_contract_owned(sender, &contract_address)?;1658 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1659 Ok(())1660 }1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1674 #[transactional]1675 pub fn add_to_contract_white_list(1676 origin,1677 contract_address: T::AccountId,1678 account_address: T::AccountId1679 ) -> DispatchResult {1680 let sender = ensure_signed(origin)?;16811682 #[cfg(feature = "runtime-benchmarks")]1683 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1684 1685 Self::ensure_contract_owned(sender, &contract_address)?; 1686 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1687 Ok(())1688 }16891690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1702 #[transactional]1703 pub fn remove_from_contract_white_list(1704 origin,1705 contract_address: T::AccountId,1706 account_address: T::AccountId1707 ) -> DispatchResult {1708 let sender = ensure_signed(origin)?;17091710 #[cfg(feature = "runtime-benchmarks")]1711 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17121713 Self::ensure_contract_owned(sender, &contract_address)?;1714 <ContractWhiteList<T>>::remove(contract_address, account_address);1715 Ok(())1716 }17171718 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1719 #[transactional]1720 pub fn set_collection_limits(1721 origin,1722 collection_id: u32,1723 new_limits: CollectionLimits<T::BlockNumber>,1724 ) -> DispatchResult {1725 let sender = ensure_signed(origin)?;1726 let mut target_collection = Self::get_collection(collection_id)?;1727 Self::check_owner_permissions(&target_collection, sender.clone())?;1728 let old_limits = &target_collection.limits;1729 let chain_limits = ChainLimit::get();17301731 1732 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1733 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1734 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1735 Error::<T>::CollectionLimitBoundsExceeded);17361737 1738 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1739 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17401741 ensure!(1742 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1743 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1744 Error::<T>::OwnerPermissionsCantBeReverted,1745 );17461747 target_collection.limits = new_limits;1748 Self::save_collection(target_collection);17491750 Ok(())1751 } 1752 }1753}17541755impl<T: Config> Module<T> {17561757 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1758 1759 Self::is_correct_transfer(target_collection, &recipient)?;17601761 1762 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1763 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1764 Error::<T>::NoPermission);17651766 if target_collection.access == AccessMode::WhiteList {1767 Self::check_white_list(target_collection, &sender)?;1768 Self::check_white_list(target_collection, &recipient)?;1769 }17701771 match target_collection.mode1772 {1773 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1774 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1775 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1776 _ => ()1777 };17781779 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17801781 Ok(())1782 }178317841785 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1786 let collection_id = collection.id;17871788 1789 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1790 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1791 1792 Ok(())1793 }17941795 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1796 let collection_id = collection.id;17971798 1799 let total_items: u32 = ItemListIndex::get(collection_id)1800 .checked_add(amount)1801 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1802 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1803 .checked_add(amount)1804 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1805 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1806 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18071808 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1809 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1810 Self::check_white_list(collection, owner)?;1811 Self::check_white_list(collection, sender)?;1812 }18131814 Ok(())1815 }18161817 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1818 match target_collection.mode1819 {1820 CollectionMode::NFT => {1821 if let CreateItemData::NFT(data) = data {1822 1823 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1824 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1825 } else {1826 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1827 }1828 },1829 CollectionMode::Fungible(_) => {1830 if let CreateItemData::Fungible(_) = data {1831 } else {1832 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1833 }1834 },1835 CollectionMode::ReFungible => {1836 if let CreateItemData::ReFungible(data) = data {18371838 1839 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1840 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18411842 1843 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1844 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1845 } else {1846 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1847 }1848 },1849 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1850 };18511852 Ok(())1853 }18541855 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1856 let collection_id = collection.id;18571858 match data1859 {1860 CreateItemData::NFT(data) => {1861 let item = NftItemType {1862 owner: owner.clone(),1863 const_data: data.const_data,1864 variable_data: data.variable_data1865 };18661867 Self::add_nft_item(collection, item)?;1868 },1869 CreateItemData::Fungible(data) => {1870 Self::add_fungible_item(collection, &owner, data.value)?;1871 },1872 CreateItemData::ReFungible(data) => {1873 let mut owner_list = Vec::new();1874 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18751876 let item = ReFungibleItemType {1877 owner: owner_list,1878 const_data: data.const_data,1879 variable_data: data.variable_data1880 };18811882 Self::add_refungible_item(collection, item)?;1883 }1884 };18851886 Ok(())1887 }18881889 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1890 let collection_id = collection.id;18911892 1893 let mut balance: u128 = 0;1894 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1895 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1896 } 18971898 1899 let item = FungibleItemType {1900 value: balance + value1901 };1902 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19031904 1905 let new_balance = <Balance<T>>::get(collection_id, owner)1906 .checked_add(value)1907 .ok_or(Error::<T>::NumOverflow)?;1908 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19091910 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1911 Ok(())1912 }19131914 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1915 let collection_id = collection.id;19161917 let current_index = <ItemListIndex>::get(collection_id)1918 .checked_add(1)1919 .ok_or(Error::<T>::NumOverflow)?;1920 let itemcopy = item.clone();19211922 ensure!(1923 item.owner.len() == 1,1924 Error::<T>::BadCreateRefungibleCall,1925 );1926 let item_owner = item.owner.first().expect("only one owner is defined");19271928 let value = item_owner.fraction;1929 let owner = item_owner.owner.clone();19301931 Self::add_token_index(collection_id, current_index, &owner)?;19321933 <ItemListIndex>::insert(collection_id, current_index);1934 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19351936 1937 let new_balance = <Balance<T>>::get(collection_id, &owner)1938 .checked_add(value)1939 .ok_or(Error::<T>::NumOverflow)?;1940 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19411942 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1943 Ok(())1944 }19451946 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1947 let collection_id = collection.id;19481949 let current_index = <ItemListIndex>::get(collection_id)1950 .checked_add(1)1951 .ok_or(Error::<T>::NumOverflow)?;19521953 let item_owner = item.owner.clone();1954 Self::add_token_index(collection_id, current_index, &item.owner)?;19551956 <ItemListIndex>::insert(collection_id, current_index);1957 <NftItemList<T>>::insert(collection_id, current_index, item);19581959 1960 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1961 .checked_add(1)1962 .ok_or(Error::<T>::NumOverflow)?;1963 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19641965 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1966 Ok(())1967 }19681969 fn burn_refungible_item(1970 collection: &CollectionHandle<T>,1971 item_id: TokenId,1972 owner: &T::AccountId,1973 ) -> DispatchResult {1974 let collection_id = collection.id;19751976 ensure!(1977 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1978 Error::<T>::TokenNotFound1979 );1980 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1981 let rft_balance = token1982 .owner1983 .iter()1984 .find(|&i| i.owner == *owner)1985 .ok_or(Error::<T>::TokenNotFound)?;1986 Self::remove_token_index(collection_id, item_id, owner)?;19871988 1989 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1990 .checked_sub(rft_balance.fraction)1991 .ok_or(Error::<T>::NumOverflow)?;1992 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19931994 1995 let index = token1996 .owner1997 .iter()1998 .position(|i| i.owner == *owner)1999 .expect("owned item is exists");2000 token.owner.remove(index);2001 let owner_count = token.owner.len();20022003 2004 if owner_count == 0 {2005 <ReFungibleItemList<T>>::remove(collection_id, item_id);2006 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2007 }2008 else {2009 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2010 }20112012 Ok(())2013 }20142015 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2016 let collection_id = collection.id;20172018 ensure!(2019 <NftItemList<T>>::contains_key(collection_id, item_id),2020 Error::<T>::TokenNotFound2021 );2022 let item = <NftItemList<T>>::get(collection_id, item_id);2023 Self::remove_token_index(collection_id, item_id, &item.owner)?;20242025 2026 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2027 .checked_sub(1)2028 .ok_or(Error::<T>::NumOverflow)?;2029 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2030 <NftItemList<T>>::remove(collection_id, item_id);2031 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20322033 Ok(())2034 }20352036 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2037 let collection_id = collection.id;20382039 ensure!(2040 <FungibleItemList<T>>::contains_key(collection_id, owner),2041 Error::<T>::TokenNotFound2042 );2043 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2044 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20452046 2047 let new_balance = <Balance<T>>::get(collection_id, owner)2048 .checked_sub(value)2049 .ok_or(Error::<T>::NumOverflow)?;2050 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20512052 if balance.value - value > 0 {2053 balance.value -= value;2054 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2055 }2056 else {2057 <FungibleItemList<T>>::remove(collection_id, owner);2058 }20592060 Ok(())2061 }20622063 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2064 Ok(<CollectionById<T>>::get(collection_id)2065 .map(|collection| CollectionHandle {2066 id: collection_id,2067 collection2068 })2069 .ok_or(Error::<T>::CollectionNotFound)?)2070 }20712072 fn save_collection(collection: CollectionHandle<T>) {2073 <CollectionById<T>>::insert(collection.id, collection.collection);2074 }20752076 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2077 ensure!(2078 subject == target_collection.owner,2079 Error::<T>::NoPermission2080 );20812082 Ok(())2083 }20842085 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2086 let mut result: bool = subject == collection.owner;2087 let exists = <AdminList<T>>::contains_key(collection.id);20882089 if !result & exists {2090 if <AdminList<T>>::get(collection.id).contains(&subject) {2091 result = true2092 }2093 }20942095 result2096 }20972098 fn check_owner_or_admin_permissions(2099 collection: &CollectionHandle<T>,2100 subject: T::AccountId,2101 ) -> DispatchResult {2102 let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21032104 ensure!(2105 result,2106 Error::<T>::NoPermission2107 );2108 Ok(())2109 }21102111 fn owned_amount(2112 subject: T::AccountId,2113 target_collection: &CollectionHandle<T>,2114 item_id: TokenId,2115 ) -> Option<u128> {2116 let collection_id = target_collection.id;21172118 match target_collection.mode {2119 CollectionMode::NFT => {2120 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2121 return Some(1)2122 }2123 None2124 },2125 CollectionMode::Fungible(_) => {2126 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2127 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2128 .value);2129 }2130 None2131 },2132 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2133 .owner2134 .iter()2135 .find(|i| i.owner == subject)2136 .map(|i| i.fraction),2137 CollectionMode::Invalid => None,2138 }2139 }21402141 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2142 let collection_id = target_collection.id;21432144 match target_collection.mode {2145 CollectionMode::NFT => {2146 <NftItemList<T>>::get(collection_id, item_id).owner == subject2147 }2148 CollectionMode::Fungible(_) => {2149 <FungibleItemList<T>>::contains_key(collection_id, &subject)2150 }2151 CollectionMode::ReFungible => {2152 <ReFungibleItemList<T>>::get(collection_id, item_id)2153 .owner2154 .iter()2155 .any(|i| i.owner == subject)2156 }2157 CollectionMode::Invalid => false,2158 }2159 }21602161 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2162 let collection_id = collection.id;21632164 let mes = Error::<T>::AddresNotInWhiteList;2165 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21662167 Ok(())2168 }21692170 2171 2172 fn token_exists(2173 target_collection: &CollectionHandle<T>,2174 item_id: TokenId,2175 owner: &T::AccountId2176 ) -> DispatchResult {2177 let collection_id = target_collection.id;2178 let exists = match target_collection.mode2179 {2180 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2181 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2182 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2183 _ => false2184 };21852186 ensure!(exists == true, Error::<T>::TokenNotFound);2187 Ok(())2188 }21892190 fn transfer_fungible(2191 collection: &CollectionHandle<T>,2192 value: u128,2193 owner: &T::AccountId,2194 recipient: &T::AccountId,2195 ) -> DispatchResult {2196 let collection_id = collection.id;2197 Self::token_exists(&collection, 0, owner)?;21982199 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2200 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22012202 2203 Self::add_fungible_item(collection, recipient, value)?;22042205 2206 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22072208 2209 if balance.value == value {2210 <FungibleItemList<T>>::remove(collection_id, owner);2211 }2212 else {2213 balance.value -= value;2214 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2215 }22162217 Ok(())2218 }22192220 fn transfer_refungible(2221 collection: &CollectionHandle<T>,2222 item_id: TokenId,2223 value: u128,2224 owner: T::AccountId,2225 new_owner: T::AccountId,2226 ) -> DispatchResult {2227 let collection_id = collection.id;2228 Self::token_exists(collection, item_id, &owner)?;22292230 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2231 let item = full_item2232 .owner2233 .iter()2234 .filter(|i| i.owner == owner)2235 .next()2236 .ok_or(Error::<T>::TokenNotFound)?;2237 let amount = item.fraction;22382239 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22402241 2242 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2243 .checked_sub(value)2244 .ok_or(Error::<T>::NumOverflow)?;2245 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22462247 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2248 .checked_add(value)2249 .ok_or(Error::<T>::NumOverflow)?;2250 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22512252 let old_owner = item.owner.clone();2253 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22542255 2256 if amount == value && !new_owner_has_account {2257 2258 2259 let mut new_full_item = full_item.clone();2260 new_full_item2261 .owner2262 .iter_mut()2263 .find(|i| i.owner == owner)2264 .expect("old owner does present in refungible")2265 .owner = new_owner.clone();2266 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22672268 2269 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2270 } else {2271 let mut new_full_item = full_item.clone();2272 new_full_item2273 .owner2274 .iter_mut()2275 .find(|i| i.owner == owner)2276 .expect("old owner does present in refungible")2277 .fraction -= value;22782279 2280 if new_owner_has_account {2281 2282 new_full_item2283 .owner2284 .iter_mut()2285 .find(|i| i.owner == new_owner)2286 .expect("new owner has account")2287 .fraction += value;2288 } else {2289 2290 new_full_item.owner.push(Ownership {2291 owner: new_owner.clone(),2292 fraction: value,2293 });2294 Self::add_token_index(collection_id, item_id, &new_owner)?;2295 }22962297 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2298 }22992300 Ok(())2301 }23022303 fn transfer_nft(2304 collection: &CollectionHandle<T>,2305 item_id: TokenId,2306 sender: T::AccountId,2307 new_owner: T::AccountId,2308 ) -> DispatchResult {2309 let collection_id = collection.id;2310 Self::token_exists(&collection, item_id, &sender)?;23112312 let mut item = <NftItemList<T>>::get(collection_id, item_id);23132314 ensure!(2315 sender == item.owner,2316 Error::<T>::MustBeTokenOwner2317 );23182319 2320 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2321 .checked_sub(1)2322 .ok_or(Error::<T>::NumOverflow)?;2323 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23242325 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2326 .checked_add(1)2327 .ok_or(Error::<T>::NumOverflow)?;2328 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23292330 2331 let old_owner = item.owner.clone();2332 item.owner = new_owner.clone();2333 <NftItemList<T>>::insert(collection_id, item_id, item);23342335 2336 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23372338 Ok(())2339 }2340 2341 fn set_re_fungible_variable_data(2342 collection: &CollectionHandle<T>,2343 item_id: TokenId,2344 data: Vec<u8>2345 ) -> DispatchResult {2346 let collection_id = collection.id;2347 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23482349 item.variable_data = data;23502351 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23522353 Ok(())2354 }23552356 fn set_nft_variable_data(2357 collection: &CollectionHandle<T>,2358 item_id: TokenId,2359 data: Vec<u8>2360 ) -> DispatchResult {2361 let collection_id = collection.id;2362 let mut item = <NftItemList<T>>::get(collection_id, item_id);2363 2364 item.variable_data = data;23652366 <NftItemList<T>>::insert(collection_id, item_id, item);2367 2368 Ok(())2369 }23702371 fn init_collection(item: &Collection<T>) {2372 2373 assert!(2374 item.decimal_points <= MAX_DECIMAL_POINTS,2375 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2376 );2377 assert!(2378 item.name.len() <= 64,2379 "Collection name can not be longer than 63 char"2380 );2381 assert!(2382 item.name.len() <= 256,2383 "Collection description can not be longer than 255 char"2384 );2385 assert!(2386 item.token_prefix.len() <= 16,2387 "Token prefix can not be longer than 15 char"2388 );23892390 2391 let next_id = CreatedCollectionCount::get()2392 .checked_add(1)2393 .unwrap();23942395 CreatedCollectionCount::put(next_id);2396 }23972398 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2399 let current_index = <ItemListIndex>::get(collection_id)2400 .checked_add(1)2401 .unwrap();24022403 let item_owner = item.owner.clone();2404 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24052406 <ItemListIndex>::insert(collection_id, current_index);24072408 2409 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2410 .checked_add(1)2411 .unwrap();2412 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2413 }24142415 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2416 let current_index = <ItemListIndex>::get(collection_id)2417 .checked_add(1)2418 .unwrap();24192420 Self::add_token_index(collection_id, current_index, owner).unwrap();24212422 <ItemListIndex>::insert(collection_id, current_index);24232424 2425 let new_balance = <Balance<T>>::get(collection_id, owner)2426 .checked_add(item.value)2427 .unwrap();2428 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2429 }24302431 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2432 let current_index = <ItemListIndex>::get(collection_id)2433 .checked_add(1)2434 .unwrap();24352436 let value = item.owner.first().unwrap().fraction;2437 let owner = item.owner.first().unwrap().owner.clone();24382439 Self::add_token_index(collection_id, current_index, &owner).unwrap();24402441 <ItemListIndex>::insert(collection_id, current_index);24422443 2444 let new_balance = <Balance<T>>::get(collection_id, &owner)2445 .checked_add(value)2446 .unwrap();2447 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2448 }24492450 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2451 2452 if <AccountItemCount<T>>::contains_key(owner) {24532454 2455 let count = <AccountItemCount<T>>::get(owner);2456 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24572458 <AccountItemCount<T>>::insert(owner.clone(), count2459 .checked_add(1)2460 .ok_or(Error::<T>::NumOverflow)?);2461 }2462 else {2463 <AccountItemCount<T>>::insert(owner.clone(), 1);2464 }24652466 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2467 if list_exists {2468 let mut list = <AddressTokens<T>>::get(collection_id, owner);2469 let item_contains = list.contains(&item_index.clone());24702471 if !item_contains {2472 list.push(item_index.clone());2473 }24742475 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2476 } else {2477 let mut itm = Vec::new();2478 itm.push(item_index.clone());2479 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2480 }24812482 Ok(())2483 }24842485 fn remove_token_index(2486 collection_id: CollectionId,2487 item_index: TokenId,2488 owner: &T::AccountId,2489 ) -> DispatchResult {24902491 2492 <AccountItemCount<T>>::insert(owner.clone(), 2493 <AccountItemCount<T>>::get(owner)2494 .checked_sub(1)2495 .ok_or(Error::<T>::NumOverflow)?);249624972498 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2499 if list_exists {2500 let mut list = <AddressTokens<T>>::get(collection_id, owner);2501 let item_contains = list.contains(&item_index.clone());25022503 if item_contains {2504 list.retain(|&item| item != item_index);2505 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2506 }2507 }25082509 Ok(())2510 }25112512 fn move_token_index(2513 collection_id: CollectionId,2514 item_index: TokenId,2515 old_owner: &T::AccountId,2516 new_owner: &T::AccountId,2517 ) -> DispatchResult {2518 Self::remove_token_index(collection_id, item_index, old_owner)?;2519 Self::add_token_index(collection_id, item_index, new_owner)?;25202521 Ok(())2522 }2523 2524 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2525 if <ContractOwner<T>>::contains_key(contract.clone()) {2526 let owner = <ContractOwner<T>>::get(contract);2527 ensure!(account == owner, Error::<T>::NoPermission);2528 } else {2529 fail!(Error::<T>::NoPermission);2530 }25312532 Ok(())2533 }2534}2535253625372538253925402541pub type Multiplier = FixedU128;25422543type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2544254525462547#[derive(Encode, Decode, Clone, Eq, PartialEq)]2548pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25492550impl<T: Config + Send + Sync> sp_std::fmt::Debug 2551 for ChargeTransactionPayment<T>2552{2553 #[cfg(feature = "std")]2554 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2555 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2556 }2557 #[cfg(not(feature = "std"))]2558 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2559 Ok(())2560 }2561}25622563impl<T: Config> ChargeTransactionPayment<T>2564where2565 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2566 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2567 T::AccountId: AsRef<[u8]>,2568 T::AccountId: UncheckedFrom<T::Hash>,2569{2570 fn traditional_fee(2571 len: usize,2572 info: &DispatchInfoOf<T::Call>,2573 tip: BalanceOf<T>,2574 ) -> BalanceOf<T>2575 where2576 T::Call: Dispatchable<Info = DispatchInfo>,2577 {2578 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2579 }25802581 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2582 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2583 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2584 let len_saturation = max_block_length as u64 / (len as u64).max(1);2585 let coefficient: BalanceOf<T> = weight_saturation2586 .min(len_saturation)2587 .saturated_into::<BalanceOf<T>>();2588 final_fee2589 .saturating_mul(coefficient)2590 .saturated_into::<TransactionPriority>()2591 }25922593 fn withdraw_fee(2594 &self,2595 who: &T::AccountId,2596 call: &T::Call,2597 info: &DispatchInfoOf<T::Call>,2598 len: usize,2599 ) -> Result<2600 (2601 BalanceOf<T>,2602 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2603 ),2604 TransactionValidityError,2605 > {2606 let tip = self.0;26072608 let fee = Self::traditional_fee(len, info, tip);26092610 2611 if fee.is_zero() {2612 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2613 .map(|i| (fee, i));2614 }26152616 2617 2618 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2619 Some(Call::create_item(collection_id, _owner, _properties)) => {2620 let collection = <CollectionById<T>>::get(collection_id)?;26212622 2623 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26242625 let collection = <Collection<T>>::get(collection_id);26262627 let limit = collection.limits.sponsor_transfer_timeout;2628 let mut sponsored = true;2629 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2630 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2631 let limit_time = last_tx_block + limit.into();2632 if block_number <= limit_time {2633 return None;2634 }2635 }2636 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26372638 2639 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2640 (sponsored)2641 {2642 collection.sponsorship.sponsor()2643 .cloned()2644 } else {2645 None2646 }2647 }2648 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2649 let collection = <CollectionById<T>>::get(collection_id)?;2650 2651 let mut sponsor_transfer = false;2652 if collection.sponsorship.confirmed() {26532654 let collection_limits = collection.limits;2655 let collection_mode = collection.mode;2656 2657 2658 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2659 sponsor_transfer = match collection_mode {2660 CollectionMode::NFT => {2661 2662 2663 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2664 collection_limits.sponsor_transfer_timeout2665 } else {2666 ChainLimit::get().nft_sponsor_transfer_timeout2667 };2668 2669 let mut sponsored = true;2670 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2671 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2672 let limit_time = last_tx_block + limit.into();2673 if block_number <= limit_time {2674 sponsored = false;2675 }2676 }2677 if sponsored {2678 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2679 }26802681 sponsored2682 }2683 CollectionMode::Fungible(_) => {2684 2685 2686 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2687 collection_limits.sponsor_transfer_timeout2688 } else {2689 ChainLimit::get().fungible_sponsor_transfer_timeout2690 };2691 2692 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2693 let mut sponsored = true;2694 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2695 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2696 let limit_time = last_tx_block + limit.into();2697 if block_number <= limit_time {2698 sponsored = false;2699 }2700 }2701 if sponsored {2702 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2703 }27042705 sponsored2706 }2707 CollectionMode::ReFungible => {2708 2709 2710 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2711 collection_limits.sponsor_transfer_timeout2712 } else {2713 ChainLimit::get().refungible_sponsor_transfer_timeout2714 };2715 2716 let mut sponsored = true;2717 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2718 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2719 let limit_time = last_tx_block + limit.into();2720 if block_number <= limit_time {2721 sponsored = false;2722 }2723 }2724 if sponsored {2725 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2726 }27272728 sponsored2729 }2730 _ => {2731 false2732 },2733 };2734 }27352736 if !sponsor_transfer {2737 None2738 } else {2739 collection.sponsorship.sponsor()2740 .cloned()2741 }2742 }27432744 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2745 let mut sponsor_metadata_changes = false;27462747 let collection = <CollectionById<T>>::get(collection_id)?;27482749 if2750 collection.sponsor_confirmed &&2751 2752 2753 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2754 data.len() <= collection.limits.sponsored_data_size as usize2755 {2756 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2757 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27582759 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2760 .map(|last_block| block_number - last_block > rate_limit)2761 .unwrap_or(true) 2762 {2763 sponsor_metadata_changes = true;2764 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2765 }2766 }2767 }27682769 if !sponsor_metadata_changes {2770 None2771 } else {2772 Some(collection.sponsor)2773 }2774 }27752776 _ => None,2777 })();27782779 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2780 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27812782 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27832784 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2785 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2786 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2787 2788 if !owned_contract && white_list_enabled {2789 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2790 return Err(InvalidTransaction::Call.into());2791 }2792 }2793 },2794 _ => {},2795 }27962797 2798 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27992800 2801 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28022803 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2804 &who,2805 code_hash,2806 salt,2807 );2808 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28092810 None2811 },28122813 2814 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28152816 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2817 &who,2818 &T::Hashing::hash(&_code),2819 _salt,2820 );28212822 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28232824 None2825 }28262827 2828 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28292830 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28312832 let mut sponsor_transfer = false;2833 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2834 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2835 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2836 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2837 let limit_time = last_tx_block + rate_limit;28382839 if block_number >= limit_time {2840 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2841 sponsor_transfer = true;2842 }2843 } else {2844 sponsor_transfer = false;2845 }2846 2847 if sponsor_transfer {2848 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2849 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2850 return Some(called_contract);2851 }2852 }2853 }28542855 None2856 },28572858 _ => None,2859 });28602861 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28622863 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2864 .map(|i| (fee, i))2865 }2866}286728682869impl<T: Config + Send + Sync> SignedExtension2870 for ChargeTransactionPayment<T>2871where2872 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2873 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2874 T::AccountId: AsRef<[u8]>,2875 T::AccountId: UncheckedFrom<T::Hash>,2876{2877 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2878 type AccountId = T::AccountId;2879 type Call = T::Call;2880 type AdditionalSigned = ();2881 type Pre = (2882 2883 BalanceOf<T>,2884 2885 Self::AccountId,2886 2887 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2888 );2889 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2890 Ok(())2891 }28922893 fn validate(2894 &self,2895 who: &Self::AccountId,2896 call: &Self::Call,2897 info: &DispatchInfoOf<Self::Call>,2898 len: usize,2899 ) -> TransactionValidity {2900 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2901 Ok(ValidTransaction {2902 priority: Self::get_priority(len, info, fee),2903 ..Default::default()2904 })2905 }29062907 fn pre_dispatch(2908 self,2909 who: &Self::AccountId,2910 call: &Self::Call,2911 info: &DispatchInfoOf<Self::Call>,2912 len: usize,2913 ) -> Result<Self::Pre, TransactionValidityError> {2914 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2915 Ok((self.0, who.clone(), imbalance))2916 }29172918 fn post_dispatch(2919 pre: Self::Pre,2920 info: &DispatchInfoOf<Self::Call>,2921 post_info: &PostDispatchInfoOf<Self::Call>,2922 len: usize,2923 _result: &DispatchResult,2924 ) -> Result<(), TransactionValidityError> {2925 let (tip, who, imbalance) = pre;2926 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2927 len as u32,2928 info,2929 post_info,2930 tip,2931 );2932 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2933 Ok(())2934 }2935}29362937