123456#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465666768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 134 Disabled,135 Unconfirmed(AccountId),136 137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, 174 pub description: Vec<u16>, 175 pub token_prefix: Vec<u8>, 176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::AccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, 181 pub variable_on_chain_schema: Vec<u8>, 182 pub const_on_chain_schema: Vec<u8>, 183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191 type Target = Collection<T>;192193 fn deref(&self) -> &Self::Target {194 &self.collection195 }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199 fn deref_mut(&mut self) -> &mut Self::Target {200 &mut self.collection201 }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207 pub owner: AccountId,208 pub const_data: Vec<u8>,209 pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215 pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221 pub owner: Vec<Ownership<AccountId>>,222 pub const_data: Vec<u8>,223 pub variable_data: Vec<u8>,224}225226227228229230231232233234235236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240 pub account_token_ownership_limit: u32,241 pub sponsored_data_size: u32,242 243 244 245 pub sponsored_data_rate_limit: Option<BlockNumber>,246 pub token_limit: u32,247248 249 pub sponsor_transfer_timeout: u32,250 pub owner_can_transfer: bool,251 pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255 fn default() -> Self {256 Self { 257 account_token_ownership_limit: 10_000_000, 258 token_limit: u32::max_value(),259 sponsored_data_size: u32::MAX, 260 sponsored_data_rate_limit: None,261 sponsor_transfer_timeout: 14400,262 owner_can_transfer: true,263 owner_can_destroy: true264 }265 }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271 pub collection_numbers_limit: u32,272 pub account_token_ownership_limit: u32,273 pub collections_admins_limit: u64,274 pub custom_data_limit: u32,275276 277 pub nft_sponsor_transfer_timeout: u32,278 pub fungible_sponsor_transfer_timeout: u32,279 pub refungible_sponsor_transfer_timeout: u32,280281 282 pub offchain_schema_limit: u32,283 pub variable_on_chain_schema_limit: u32,284 pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288 fn create_collection() -> Weight;289 fn destroy_collection() -> Weight;290 fn add_to_white_list() -> Weight;291 fn remove_from_white_list() -> Weight;292 fn set_public_access_mode() -> Weight;293 fn set_mint_permission() -> Weight;294 fn change_collection_owner() -> Weight;295 fn add_collection_admin() -> Weight;296 fn remove_collection_admin() -> Weight;297 fn set_collection_sponsor() -> Weight;298 fn confirm_sponsorship() -> Weight;299 fn remove_collection_sponsor() -> Weight;300 fn create_item(s: usize) -> Weight;301 fn burn_item() -> Weight;302 fn transfer() -> Weight;303 fn approve() -> Weight;304 fn transfer_from() -> Weight;305 fn set_offchain_schema() -> Weight;306 fn set_const_on_chain_schema() -> Weight;307 fn set_variable_on_chain_schema() -> Weight;308 fn set_variable_meta_data() -> Weight;309 fn enable_contract_sponsoring() -> Weight;310 fn set_schema_version() -> Weight;311 fn set_chain_limits() -> Weight;312 fn set_contract_sponsoring_rate_limit() -> Weight;313 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314 fn toggle_contract_white_list() -> Weight;315 fn add_to_contract_white_list() -> Weight;316 fn remove_from_contract_white_list() -> Weight;317 fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323 pub const_data: Vec<u8>,324 pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330 pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336 pub const_data: Vec<u8>,337 pub variable_data: Vec<u8>,338 pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344 NFT(CreateNftData),345 Fungible(CreateFungibleData),346 ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350 pub fn len(&self) -> usize {351 let len = match self {352 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354 _ => 0355 };356 357 return len;358 }359}360361impl From<CreateNftData> for CreateItemData {362 fn from(item: CreateNftData) -> Self {363 CreateItemData::NFT(item)364 }365}366367impl From<CreateReFungibleData> for CreateItemData {368 fn from(item: CreateReFungibleData) -> Self {369 CreateItemData::ReFungible(item)370 }371}372373impl From<CreateFungibleData> for CreateItemData {374 fn from(item: CreateFungibleData) -> Self {375 CreateItemData::Fungible(item)376 }377}378379380decl_error! {381 382 pub enum Error for Module<T: Config> {383 384 TotalCollectionsLimitExceeded,385 386 CollectionDecimalPointLimitExceeded, 387 388 CollectionNameLimitExceeded, 389 390 CollectionDescriptionLimitExceeded, 391 392 CollectionTokenPrefixLimitExceeded,393 394 CollectionNotFound,395 396 TokenNotFound,397 398 AdminNotFound,399 400 NumOverflow, 401 402 AlreadyAdmin, 403 404 NoPermission,405 406 ConfirmUnsetSponsorFail,407 408 PublicMintingNotAllowed,409 410 MustBeTokenOwner,411 412 TokenValueTooLow,413 414 NftSizeLimitExceeded,415 416 ApproveNotFound,417 418 TokenValueNotEnough,419 420 ApproveRequired,421 422 AddresNotInWhiteList,423 424 CollectionAdminsLimitExceeded,425 426 AddressOwnershipLimitExceeded,427 428 EmptyArgument,429 430 TokenConstDataLimitExceeded,431 432 TokenVariableDataLimitExceeded,433 434 NotNftDataUsedToMintNftCollectionToken,435 436 NotFungibleDataUsedToMintFungibleCollectionToken,437 438 NotReFungibleDataUsedToMintReFungibleCollectionToken,439 440 UnexpectedCollectionType,441 442 CantStoreMetadataInFungibleTokens,443 444 CollectionTokenLimitExceeded,445 446 AccountTokenLimitExceeded,447 448 CollectionLimitBoundsExceeded,449 450 OwnerPermissionsCantBeReverted,451 452 SchemaDataLimitExceeded,453 454 WrongRefungiblePieces,455 456 BadCreateRefungibleCall,457 }458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463 464 type WeightInfo: WeightInfo;465466 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470 type CrossAccountId: CrossAccountId<Self::AccountId>;471 type Currency: Currency<Self::AccountId>;472 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473 type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479480481482483484485486487488489490491492493494495496497498499500501502503decl_storage! {504 trait Store for Module<T: Config> as Nft {505506 507 508 CreatedCollectionCount: u32;509 510 ChainVersion: u64;511 512 513 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514 515516 517 pub ChainLimit get(fn chain_limit) config(): ChainLimits;518 519520 521 522 523 DestroyedCollectionCount: u32;524 525 526 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527 528529 530 531 532 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533 534 535 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536 537 538 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539 540541 542 543 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545 546 547 548 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550 551 552 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553 554 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555 556 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557 558559 560 561 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562 563564 565 566 567 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568 569 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570 571 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572 573 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574 575576 577 578 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579 580 581 582 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583 584 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585 586 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587 588 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589 590 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591 592 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593 594 }595 add_extra_genesis {596 build(|config: &GenesisConfig<T>| {597 598 for (_num, _c) in &config.collection_id {599 <Module<T>>::init_collection(_c);600 }601602 for (_num, _c, _i) in &config.nft_item_id {603 <Module<T>>::init_nft_token(*_c, _i);604 }605606 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);608 }609610 for (_num, _c, _i) in &config.refungible_item_id {611 <Module<T>>::init_refungible_token(*_c, _i);612 }613 })614 }615}616617decl_event!(618 pub enum Event<T>619 where620 CrossAccountId = <T as Config>::CrossAccountId,621 {622 623 624 625 626 627 628 629 630 631 CollectionCreated(CollectionId, u8, CrossAccountId),632633 634 635 636 637 638 639 640 641 642 ItemCreated(CollectionId, TokenId, CrossAccountId),643644 645 646 647 648 649 650 651 ItemDestroyed(CollectionId, TokenId),652653 654 655 656 657 658 659 660 661 662 663 664 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666 667 668 669 670 671 672 673 674 675 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676 }677);678679decl_module! {680 pub struct Module<T: Config> for enum Call 681 where 682 origin: T::Origin683 {684 fn deposit_event() = default;685 type Error = Error<T>;686687 fn on_initialize(now: T::BlockNumber) -> Weight {688 0689 }690691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 #[weight = <T as Config>::WeightInfo::create_collection()]708 #[transactional]709 pub fn create_collection(origin,710 collection_name: Vec<u16>,711 collection_description: Vec<u16>,712 token_prefix: Vec<u8>,713 mode: CollectionMode) -> DispatchResult {714715 716 let who = T::CrossAccountId::from_sub(ensure_signed(origin)?);717718 719 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721 &T::TreasuryAccountId::get(),722 T::CollectionCreationPrice::get(),723 ));724 <T as Config>::Currency::settle(725 who.as_sub(),726 imbalance,727 WithdrawReasons::TRANSFER,728 ExistenceRequirement::KeepAlive,729 ).map_err(|_| Error::<T>::NoPermission)?;730731 let decimal_points = match mode {732 CollectionMode::Fungible(points) => points,733 _ => 0734 };735736 let chain_limit = ChainLimit::get();737738 let created_count = CreatedCollectionCount::get();739 let destroyed_count = DestroyedCollectionCount::get();740741 742 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744 745 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750 751 let next_id = created_count752 .checked_add(1)753 .ok_or(Error::<T>::NumOverflow)?;754755 CreatedCollectionCount::put(next_id);756757 let limits = CollectionLimits {758 sponsored_data_size: chain_limit.custom_data_limit,759 ..Default::default()760 };761762 763 let new_collection = Collection {764 owner: who.clone(),765 name: collection_name,766 mode: mode.clone(),767 mint_mode: false,768 access: AccessMode::Normal,769 description: collection_description,770 decimal_points: decimal_points,771 token_prefix: token_prefix,772 offchain_schema: Vec::new(),773 schema_version: SchemaVersion::ImageURL,774 sponsorship: SponsorshipState::Disabled,775 variable_on_chain_schema: Vec::new(),776 const_on_chain_schema: Vec::new(),777 limits,778 };779780 781 <CollectionById<T>>::insert(next_id, new_collection);782783 784 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));785786 Ok(())787 }788789 790 791 792 793 794 795 796 797 798 #[weight = <T as Config>::WeightInfo::destroy_collection()]799 #[transactional]800 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);803 let collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&collection, sender)?;805 if !collection.limits.owner_can_destroy {806 fail!(Error::<T>::NoPermission);807 }808809 <AddressTokens<T>>::remove_prefix(collection_id);810 <Allowances<T>>::remove_prefix(collection_id);811 <Balance<T>>::remove_prefix(collection_id);812 <ItemListIndex>::remove(collection_id);813 <AdminList<T>>::remove(collection_id);814 <CollectionById<T>>::remove(collection_id);815 <WhiteList<T>>::remove_prefix(collection_id);816817 <NftItemList<T>>::remove_prefix(collection_id);818 <FungibleItemList<T>>::remove_prefix(collection_id);819 <ReFungibleItemList<T>>::remove_prefix(collection_id);820821 <NftTransferBasket<T>>::remove_prefix(collection_id);822 <FungibleTransferBasket<T>>::remove_prefix(collection_id);823 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827 DestroyedCollectionCount::put(DestroyedCollectionCount::get()828 .checked_add(1)829 .ok_or(Error::<T>::NumOverflow)?);830831 Ok(())832 }833834 835 836 837 838 839 840 841 842 843 844 845 846 #[weight = <T as Config>::WeightInfo::add_to_white_list()]847 #[transactional]848 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{849850 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);851 let collection = Self::get_collection(collection_id)?;852 Self::check_owner_or_admin_permissions(&collection, sender)?;853854 <WhiteList<T>>::insert(collection_id, address.as_sub(), true);855 856 Ok(())857 }858859 860 861 862 863 864 865 866 867 868 869 870 871 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872 #[transactional]873 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{874875 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876 let collection = Self::get_collection(collection_id)?;877 Self::check_owner_or_admin_permissions(&collection, sender)?;878879 <WhiteList<T>>::remove(collection_id, address.as_sub());880881 Ok(())882 }883884 885 886 887 888 889 890 891 892 893 894 895 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896 #[transactional]897 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898 {899 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);900901 let mut target_collection = Self::get_collection(collection_id)?;902 Self::check_owner_permissions(&target_collection, sender)?;903 target_collection.access = mode;904 Self::save_collection(target_collection);905906 Ok(())907 }908909 910 911 912 913 914 915 916 917 918 919 920 921 922 #[weight = <T as Config>::WeightInfo::set_mint_permission()]923 #[transactional]924 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925 {926 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);927928 let mut target_collection = Self::get_collection(collection_id)?;929 Self::check_owner_permissions(&target_collection, sender)?;930 target_collection.mint_mode = mint_permission;931 Self::save_collection(target_collection);932933 Ok(())934 }935936 937 938 939 940 941 942 943 944 945 946 947 #[weight = <T as Config>::WeightInfo::change_collection_owner()]948 #[transactional]949 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::CrossAccountId) -> DispatchResult {950951 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);952 let mut target_collection = Self::get_collection(collection_id)?;953 Self::check_owner_permissions(&target_collection, sender)?;954 target_collection.owner = new_owner;955 Self::save_collection(target_collection);956957 Ok(())958 }959960 961 962 963 964 965 966 967 968 969 970 971 972 973 #[weight = <T as Config>::WeightInfo::add_collection_admin()]974 #[transactional]975 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {976977 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);978 let collection = Self::get_collection(collection_id)?;979 Self::check_owner_or_admin_permissions(&collection, sender)?;980 let mut admin_arr = <AdminList<T>>::get(collection_id);981982 match admin_arr.binary_search(&new_admin_id) {983 Ok(_) => {},984 Err(idx) => {985 let limits = ChainLimit::get();986 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);987 admin_arr.insert(idx, new_admin_id);988 <AdminList<T>>::insert(collection_id, admin_arr);989 }990 }991 Ok(())992 }993994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1007 #[transactional]1008 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {10091010 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1011 let collection = Self::get_collection(collection_id)?;1012 Self::check_owner_or_admin_permissions(&collection, sender)?;1013 let mut admin_arr = <AdminList<T>>::get(collection_id);10141015 match admin_arr.binary_search(&account_id) {1016 Ok(idx) => {1017 admin_arr.remove(idx);1018 <AdminList<T>>::insert(collection_id, admin_arr);1019 },1020 Err(_) => {}1021 }1022 Ok(())1023 }10241025 1026 1027 1028 1029 1030 1031 1032 1033 1034 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1035 #[transactional]1036 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1037 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1038 let mut target_collection = Self::get_collection(collection_id)?;1039 Self::check_owner_permissions(&target_collection, &sender)?;10401041 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1042 Self::save_collection(target_collection);10431044 Ok(())1045 }10461047 1048 1049 1050 1051 1052 1053 1054 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1055 #[transactional]1056 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1057 let sender = ensure_signed(origin)?;10581059 let mut target_collection = Self::get_collection(collection_id)?;1060 ensure!(1061 target_collection.sponsorship.pending_sponsor() == Some(&sender),1062 Error::<T>::ConfirmUnsetSponsorFail1063 );10641065 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1066 Self::save_collection(target_collection);10671068 Ok(())1069 }10701071 1072 1073 1074 1075 1076 1077 1078 1079 1080 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1081 #[transactional]1082 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1083 let sender = ensure_signed(origin)?;10841085 let mut target_collection = Self::get_collection(collection_id)?;1086 Self::check_owner_permissions(&target_collection, sender)?;10871088 target_collection.sponsorship = SponsorshipState::Disabled;1089 Self::save_collection(target_collection);10901091 Ok(())1092 }10931094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 11171118 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1119 #[transactional]1120 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11211122 let sender = ensure_signed(origin)?;11231124 let target_collection = Self::get_collection(collection_id)?;11251126 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1127 Self::validate_create_item_args(&target_collection, &data)?;1128 Self::create_item_no_validation(&target_collection, owner, data)?;11291130 Ok(())1131 }11321133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1152 .map(|data| { data.len() })1153 .sum())]1154 #[transactional]1155 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11561157 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1158 let sender = ensure_signed(origin)?;11591160 let target_collection = Self::get_collection(collection_id)?;11611162 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11631164 for data in &items_data {1165 Self::validate_create_item_args(&target_collection, data)?;1166 }1167 for data in &items_data {1168 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1169 }11701171 Ok(())1172 }11731174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 #[weight = <T as Config>::WeightInfo::burn_item()]1188 #[transactional]1189 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11901191 let sender = ensure_signed(origin)?;11921193 1194 let target_collection = Self::get_collection(collection_id)?;1195 ensure!(1196 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1197 (1198 target_collection.limits.owner_can_transfer &&1199 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1200 ),1201 Error::<T>::NoPermission1202 );12031204 if target_collection.access == AccessMode::WhiteList {1205 Self::check_white_list(&target_collection, &sender)?;1206 }12071208 match target_collection.mode1209 {1210 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1211 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1212 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1213 _ => ()1214 };12151216 1217 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12181219 Ok(())1220 }12211222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 #[weight = <T as Config>::WeightInfo::transfer()]1246 #[transactional]1247 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1248 let sender = ensure_signed(origin)?;1249 let collection = Self::get_collection(collection_id)?;12501251 Self::transfer_internal(sender, recipient, &collection, item_id, value)1252 }12531254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 #[weight = <T as Config>::WeightInfo::approve()]1270 #[transactional]1271 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12721273 let sender = ensure_signed(origin)?;1274 let target_collection = Self::get_collection(collection_id)?;12751276 Self::token_exists(&target_collection, item_id)?;12771278 1279 let bypasses_limits = target_collection.limits.owner_can_transfer &&1280 Self::is_owner_or_admin_permissions(1281 &target_collection,1282 sender.clone(),1283 );12841285 let allowance_limit = if bypasses_limits {1286 None1287 } else if let Some(amount) = Self::owned_amount(1288 sender.clone(),1289 &target_collection,1290 item_id,1291 ) {1292 Some(amount)1293 } else {1294 fail!(Error::<T>::NoPermission);1295 };12961297 if target_collection.access == AccessMode::WhiteList {1298 Self::check_white_list(&target_collection, &sender)?;1299 Self::check_white_list(&target_collection, &spender)?;1300 }13011302 let allowance: u128 = amount1303 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1304 .ok_or(Error::<T>::NumOverflow)?;1305 if let Some(limit) = allowance_limit {1306 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1307 }1308 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13091310 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1311 Ok(())1312 }1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 #[weight = <T as Config>::WeightInfo::transfer_from()]1334 #[transactional]1335 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13361337 let sender = ensure_signed(origin)?;1338 let target_collection = Self::get_collection(collection_id)?;13391340 1341 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13421343 1344 Self::is_correct_transfer(&target_collection, &recipient)?;13451346 1347 ensure!(1348 approval >= value || 1349 (1350 target_collection.limits.owner_can_transfer &&1351 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1352 ),1353 Error::<T>::NoPermission1354 );13551356 if target_collection.access == AccessMode::WhiteList {1357 Self::check_white_list(&target_collection, &sender)?;1358 Self::check_white_list(&target_collection, &recipient)?;1359 }13601361 1362 if approval.saturating_sub(value) > 0 {1363 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1364 }1365 else {1366 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1367 }13681369 match target_collection.mode1370 {1371 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1372 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1373 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1374 _ => ()1375 };13761377 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1378 Ok(())1379 }13801381 1382 13831384 1385 1386 1387 13881389 13901391 13921393 1394 13951396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1409 #[transactional]1410 pub fn set_variable_meta_data (1411 origin,1412 collection_id: CollectionId,1413 item_id: TokenId,1414 data: Vec<u8>1415 ) -> DispatchResult {1416 let sender = ensure_signed(origin)?;1417 1418 let target_collection = Self::get_collection(collection_id)?;1419 Self::token_exists(&target_collection, item_id)?;14201421 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14221423 1424 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1425 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1426 Error::<T>::NoPermission);14271428 match target_collection.mode1429 {1430 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1431 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1432 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1433 _ => fail!(Error::<T>::UnexpectedCollectionType)1434 };14351436 Ok(())1437 }1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 #[weight = <T as Config>::WeightInfo::set_schema_version()]1454 #[transactional]1455 pub fn set_schema_version(1456 origin,1457 collection_id: CollectionId,1458 version: SchemaVersion1459 ) -> DispatchResult {1460 let sender = ensure_signed(origin)?;1461 let mut target_collection = Self::get_collection(collection_id)?;1462 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1463 target_collection.schema_version = version;1464 Self::save_collection(target_collection);14651466 Ok(())1467 }14681469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1482 #[transactional]1483 pub fn set_offchain_schema(1484 origin,1485 collection_id: CollectionId,1486 schema: Vec<u8>1487 ) -> DispatchResult {1488 let sender = ensure_signed(origin)?;1489 let mut target_collection = Self::get_collection(collection_id)?;1490 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14911492 1493 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14941495 target_collection.offchain_schema = schema;1496 Self::save_collection(target_collection);14971498 Ok(())1499 }15001501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1514 #[transactional]1515 pub fn set_const_on_chain_schema (1516 origin,1517 collection_id: CollectionId,1518 schema: Vec<u8>1519 ) -> DispatchResult {1520 let sender = ensure_signed(origin)?;1521 let mut target_collection = Self::get_collection(collection_id)?;1522 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15231524 1525 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15261527 target_collection.const_on_chain_schema = schema;1528 Self::save_collection(target_collection);15291530 Ok(())1531 }15321533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1546 #[transactional]1547 pub fn set_variable_on_chain_schema (1548 origin,1549 collection_id: CollectionId,1550 schema: Vec<u8>1551 ) -> DispatchResult {1552 let sender = ensure_signed(origin)?;1553 let mut target_collection = Self::get_collection(collection_id)?;1554 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15551556 1557 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15581559 target_collection.variable_on_chain_schema = schema;1560 Self::save_collection(target_collection);15611562 Ok(())1563 }15641565 1566 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1567 #[transactional]1568 pub fn set_chain_limits(1569 origin,1570 limits: ChainLimits1571 ) -> DispatchResult {15721573 #[cfg(not(feature = "runtime-benchmarks"))]1574 ensure_root(origin)?;15751576 <ChainLimit>::put(limits);1577 Ok(())1578 }15791580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1592 #[transactional]1593 pub fn enable_contract_sponsoring(1594 origin,1595 contract_address: T::AccountId,1596 enable: bool1597 ) -> DispatchResult {15981599 let sender = ensure_signed(origin)?;16001601 #[cfg(feature = "runtime-benchmarks")]1602 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16031604 Self::ensure_contract_owned(sender, &contract_address)?;16051606 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1607 Ok(())1608 }16091610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1628 #[transactional]1629 pub fn set_contract_sponsoring_rate_limit(1630 origin,1631 contract_address: T::AccountId,1632 rate_limit: T::BlockNumber1633 ) -> DispatchResult {1634 let sender = ensure_signed(origin)?;16351636 #[cfg(feature = "runtime-benchmarks")]1637 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16381639 Self::ensure_contract_owned(sender, &contract_address)?;1640 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1641 Ok(())1642 }16431644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1656 #[transactional]1657 pub fn toggle_contract_white_list(1658 origin,1659 contract_address: T::AccountId,1660 enable: bool1661 ) -> DispatchResult {1662 let sender = ensure_signed(origin)?;16631664 #[cfg(feature = "runtime-benchmarks")]1665 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16661667 Self::ensure_contract_owned(sender, &contract_address)?;1668 if enable {1669 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1670 } else {1671 <ContractWhiteListEnabled<T>>::remove(contract_address);1672 }1673 Ok(())1674 }1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1688 #[transactional]1689 pub fn add_to_contract_white_list(1690 origin,1691 contract_address: T::AccountId,1692 account_address: T::AccountId1693 ) -> DispatchResult {1694 let sender = ensure_signed(origin)?;16951696 #[cfg(feature = "runtime-benchmarks")]1697 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1698 1699 Self::ensure_contract_owned(sender, &contract_address)?; 1700 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1701 Ok(())1702 }17031704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1716 #[transactional]1717 pub fn remove_from_contract_white_list(1718 origin,1719 contract_address: T::AccountId,1720 account_address: T::AccountId1721 ) -> DispatchResult {1722 let sender = ensure_signed(origin)?;17231724 #[cfg(feature = "runtime-benchmarks")]1725 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17261727 Self::ensure_contract_owned(sender, &contract_address)?;1728 <ContractWhiteList<T>>::remove(contract_address, account_address);1729 Ok(())1730 }17311732 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1733 #[transactional]1734 pub fn set_collection_limits(1735 origin,1736 collection_id: u32,1737 new_limits: CollectionLimits<T::BlockNumber>,1738 ) -> DispatchResult {1739 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1740 let mut target_collection = Self::get_collection(collection_id)?;1741 Self::check_owner_permissions(&target_collection, sender.clone())?;1742 let old_limits = &target_collection.limits;1743 let chain_limits = ChainLimit::get();17441745 1746 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1747 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1748 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1749 Error::<T>::CollectionLimitBoundsExceeded);17501751 1752 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1753 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17541755 ensure!(1756 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1757 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1758 Error::<T>::OwnerPermissionsCantBeReverted,1759 );17601761 target_collection.limits = new_limits;1762 Self::save_collection(target_collection);17631764 Ok(())1765 } 1766 }1767}17681769impl<T: Config> Module<T> {17701771 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1772 1773 Self::is_correct_transfer(target_collection, &recipient)?;17741775 1776 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1777 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1778 Error::<T>::NoPermission);17791780 if target_collection.access == AccessMode::WhiteList {1781 Self::check_white_list(target_collection, &sender)?;1782 Self::check_white_list(target_collection, &recipient)?;1783 }17841785 match target_collection.mode1786 {1787 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1788 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1789 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1790 _ => ()1791 };17921793 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17941795 Ok(())1796 }179717981799 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1800 let collection_id = collection.id;18011802 1803 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1804 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1805 1806 Ok(())1807 }18081809 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1810 let collection_id = collection.id;18111812 1813 let total_items: u32 = ItemListIndex::get(collection_id)1814 .checked_add(amount)1815 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1816 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1817 .checked_add(amount)1818 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1819 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1820 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18211822 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1823 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1824 Self::check_white_list(collection, owner)?;1825 Self::check_white_list(collection, sender)?;1826 }18271828 Ok(())1829 }18301831 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1832 match target_collection.mode1833 {1834 CollectionMode::NFT => {1835 if let CreateItemData::NFT(data) = data {1836 1837 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1838 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1839 } else {1840 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1841 }1842 },1843 CollectionMode::Fungible(_) => {1844 if let CreateItemData::Fungible(_) = data {1845 } else {1846 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1847 }1848 },1849 CollectionMode::ReFungible => {1850 if let CreateItemData::ReFungible(data) = data {18511852 1853 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1854 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18551856 1857 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1858 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1859 } else {1860 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1861 }1862 },1863 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1864 };18651866 Ok(())1867 }18681869 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1870 match data1871 {1872 CreateItemData::NFT(data) => {1873 let item = NftItemType {1874 owner: owner.clone(),1875 const_data: data.const_data,1876 variable_data: data.variable_data1877 };18781879 Self::add_nft_item(collection, item)?;1880 },1881 CreateItemData::Fungible(data) => {1882 Self::add_fungible_item(collection, &owner, data.value)?;1883 },1884 CreateItemData::ReFungible(data) => {1885 let mut owner_list = Vec::new();1886 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18871888 let item = ReFungibleItemType {1889 owner: owner_list,1890 const_data: data.const_data,1891 variable_data: data.variable_data1892 };18931894 Self::add_refungible_item(collection, item)?;1895 }1896 };18971898 Ok(())1899 }19001901 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1902 let collection_id = collection.id;19031904 1905 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19061907 1908 let item = FungibleItemType {1909 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1910 };1911 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19121913 1914 let new_balance = <Balance<T>>::get(collection_id, owner)1915 .checked_add(value)1916 .ok_or(Error::<T>::NumOverflow)?;1917 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19181919 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1920 Ok(())1921 }19221923 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1924 let collection_id = collection.id;19251926 let current_index = <ItemListIndex>::get(collection_id)1927 .checked_add(1)1928 .ok_or(Error::<T>::NumOverflow)?;1929 let itemcopy = item.clone();19301931 ensure!(1932 item.owner.len() == 1,1933 Error::<T>::BadCreateRefungibleCall,1934 );1935 let item_owner = item.owner.first().expect("only one owner is defined");19361937 let value = item_owner.fraction;1938 let owner = item_owner.owner.clone();19391940 Self::add_token_index(collection_id, current_index, &owner)?;19411942 <ItemListIndex>::insert(collection_id, current_index);1943 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19441945 1946 let new_balance = <Balance<T>>::get(collection_id, &owner)1947 .checked_add(value)1948 .ok_or(Error::<T>::NumOverflow)?;1949 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19501951 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1952 Ok(())1953 }19541955 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1956 let collection_id = collection.id;19571958 let current_index = <ItemListIndex>::get(collection_id)1959 .checked_add(1)1960 .ok_or(Error::<T>::NumOverflow)?;19611962 let item_owner = item.owner.clone();1963 Self::add_token_index(collection_id, current_index, &item.owner)?;19641965 <ItemListIndex>::insert(collection_id, current_index);1966 <NftItemList<T>>::insert(collection_id, current_index, item);19671968 1969 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1970 .checked_add(1)1971 .ok_or(Error::<T>::NumOverflow)?;1972 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19731974 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1975 Ok(())1976 }19771978 fn burn_refungible_item(1979 collection: &CollectionHandle<T>,1980 item_id: TokenId,1981 owner: &T::AccountId,1982 ) -> DispatchResult {1983 let collection_id = collection.id;19841985 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1986 .ok_or(Error::<T>::TokenNotFound)?;1987 let rft_balance = token1988 .owner1989 .iter()1990 .find(|&i| i.owner == *owner)1991 .ok_or(Error::<T>::TokenNotFound)?;1992 Self::remove_token_index(collection_id, item_id, owner)?;19931994 1995 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1996 .checked_sub(rft_balance.fraction)1997 .ok_or(Error::<T>::NumOverflow)?;1998 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19992000 2001 let index = token2002 .owner2003 .iter()2004 .position(|i| i.owner == *owner)2005 .expect("owned item is exists");2006 token.owner.remove(index);2007 let owner_count = token.owner.len();20082009 2010 if owner_count == 0 {2011 <ReFungibleItemList<T>>::remove(collection_id, item_id);2012 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2013 }2014 else {2015 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2016 }20172018 Ok(())2019 }20202021 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2022 let collection_id = collection.id;20232024 let item = <NftItemList<T>>::get(collection_id, item_id)2025 .ok_or(Error::<T>::TokenNotFound)?;2026 Self::remove_token_index(collection_id, item_id, &item.owner)?;20272028 2029 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2030 .checked_sub(1)2031 .ok_or(Error::<T>::NumOverflow)?;2032 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2033 <NftItemList<T>>::remove(collection_id, item_id);2034 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20352036 Ok(())2037 }20382039 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2040 let collection_id = collection.id;20412042 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2043 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20442045 2046 let new_balance = <Balance<T>>::get(collection_id, owner)2047 .checked_sub(value)2048 .ok_or(Error::<T>::NumOverflow)?;2049 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20502051 if balance.value - value > 0 {2052 balance.value -= value;2053 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2054 }2055 else {2056 <FungibleItemList<T>>::remove(collection_id, owner);2057 }20582059 Ok(())2060 }20612062 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2063 Ok(<CollectionById<T>>::get(collection_id)2064 .map(|collection| CollectionHandle {2065 id: collection_id,2066 collection2067 })2068 .ok_or(Error::<T>::CollectionNotFound)?)2069 }20702071 fn save_collection(collection: CollectionHandle<T>) {2072 <CollectionById<T>>::insert(collection.id, collection.collection);2073 }20742075 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2076 ensure!(2077 subject == target_collection.owner,2078 Error::<T>::NoPermission2079 );20802081 Ok(())2082 }20832084 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2085 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2086 }20872088 fn check_owner_or_admin_permissions(2089 collection: &CollectionHandle<T>,2090 subject: T::AccountId,2091 ) -> DispatchResult {2092 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20932094 Ok(())2095 }20962097 fn owned_amount(2098 subject: T::AccountId,2099 target_collection: &CollectionHandle<T>,2100 item_id: TokenId,2101 ) -> Option<u128> {2102 let collection_id = target_collection.id;21032104 match target_collection.mode {2105 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2106 .then(|| 1),2107 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2108 .value),2109 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2110 .owner2111 .iter()2112 .find(|i| i.owner == subject)2113 .map(|i| i.fraction),2114 CollectionMode::Invalid => None,2115 }2116 }21172118 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2119 match target_collection.mode {2120 CollectionMode::Fungible(_) => true,2121 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2122 }2123 }21242125 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2126 let collection_id = collection.id;21272128 let mes = Error::<T>::AddresNotInWhiteList;2129 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21302131 Ok(())2132 }21332134 2135 2136 fn token_exists(2137 target_collection: &CollectionHandle<T>,2138 item_id: TokenId,2139 ) -> DispatchResult {2140 let collection_id = target_collection.id;2141 let exists = match target_collection.mode2142 {2143 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2144 CollectionMode::Fungible(_) => true,2145 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2146 _ => false2147 };21482149 ensure!(exists == true, Error::<T>::TokenNotFound);2150 Ok(())2151 }21522153 fn transfer_fungible(2154 collection: &CollectionHandle<T>,2155 value: u128,2156 owner: &T::AccountId,2157 recipient: &T::AccountId,2158 ) -> DispatchResult {2159 let collection_id = collection.id;21602161 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2162 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21632164 2165 Self::add_fungible_item(collection, recipient, value)?;21662167 2168 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21692170 2171 if balance.value == value {2172 <FungibleItemList<T>>::remove(collection_id, owner);2173 }2174 else {2175 balance.value -= value;2176 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2177 }21782179 Ok(())2180 }21812182 fn transfer_refungible(2183 collection: &CollectionHandle<T>,2184 item_id: TokenId,2185 value: u128,2186 owner: T::AccountId,2187 new_owner: T::AccountId,2188 ) -> DispatchResult {2189 let collection_id = collection.id;2190 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2191 .ok_or(Error::<T>::TokenNotFound)?;21922193 let item = full_item2194 .owner2195 .iter()2196 .filter(|i| i.owner == owner)2197 .next()2198 .ok_or(Error::<T>::TokenNotFound)?;2199 let amount = item.fraction;22002201 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22022203 2204 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2205 .checked_sub(value)2206 .ok_or(Error::<T>::NumOverflow)?;2207 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22082209 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2210 .checked_add(value)2211 .ok_or(Error::<T>::NumOverflow)?;2212 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22132214 let old_owner = item.owner.clone();2215 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22162217 2218 if amount == value && !new_owner_has_account {2219 2220 2221 let mut new_full_item = full_item.clone();2222 new_full_item2223 .owner2224 .iter_mut()2225 .find(|i| i.owner == owner)2226 .expect("old owner does present in refungible")2227 .owner = new_owner.clone();2228 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22292230 2231 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2232 } else {2233 let mut new_full_item = full_item.clone();2234 new_full_item2235 .owner2236 .iter_mut()2237 .find(|i| i.owner == owner)2238 .expect("old owner does present in refungible")2239 .fraction -= value;22402241 2242 if new_owner_has_account {2243 2244 new_full_item2245 .owner2246 .iter_mut()2247 .find(|i| i.owner == new_owner)2248 .expect("new owner has account")2249 .fraction += value;2250 } else {2251 2252 new_full_item.owner.push(Ownership {2253 owner: new_owner.clone(),2254 fraction: value,2255 });2256 Self::add_token_index(collection_id, item_id, &new_owner)?;2257 }22582259 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2260 }22612262 Ok(())2263 }22642265 fn transfer_nft(2266 collection: &CollectionHandle<T>,2267 item_id: TokenId,2268 sender: T::AccountId,2269 new_owner: T::AccountId,2270 ) -> DispatchResult {2271 let collection_id = collection.id;2272 let mut item = <NftItemList<T>>::get(collection_id, item_id)2273 .ok_or(Error::<T>::TokenNotFound)?;22742275 ensure!(2276 sender == item.owner,2277 Error::<T>::MustBeTokenOwner2278 );22792280 2281 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2282 .checked_sub(1)2283 .ok_or(Error::<T>::NumOverflow)?;2284 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22852286 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2287 .checked_add(1)2288 .ok_or(Error::<T>::NumOverflow)?;2289 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22902291 2292 let old_owner = item.owner.clone();2293 item.owner = new_owner.clone();2294 <NftItemList<T>>::insert(collection_id, item_id, item);22952296 2297 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22982299 Ok(())2300 }2301 2302 fn set_re_fungible_variable_data(2303 collection: &CollectionHandle<T>,2304 item_id: TokenId,2305 data: Vec<u8>2306 ) -> DispatchResult {2307 let collection_id = collection.id;2308 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2309 .ok_or(Error::<T>::TokenNotFound)?;23102311 item.variable_data = data;23122313 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23142315 Ok(())2316 }23172318 fn set_nft_variable_data(2319 collection: &CollectionHandle<T>,2320 item_id: TokenId,2321 data: Vec<u8>2322 ) -> DispatchResult {2323 let collection_id = collection.id;2324 let mut item = <NftItemList<T>>::get(collection_id, item_id)2325 .ok_or(Error::<T>::TokenNotFound)?;2326 2327 item.variable_data = data;23282329 <NftItemList<T>>::insert(collection_id, item_id, item);2330 2331 Ok(())2332 }23332334 fn init_collection(item: &Collection<T>) {2335 2336 assert!(2337 item.decimal_points <= MAX_DECIMAL_POINTS,2338 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2339 );2340 assert!(2341 item.name.len() <= 64,2342 "Collection name can not be longer than 63 char"2343 );2344 assert!(2345 item.name.len() <= 256,2346 "Collection description can not be longer than 255 char"2347 );2348 assert!(2349 item.token_prefix.len() <= 16,2350 "Token prefix can not be longer than 15 char"2351 );23522353 2354 let next_id = CreatedCollectionCount::get()2355 .checked_add(1)2356 .unwrap();23572358 CreatedCollectionCount::put(next_id);2359 }23602361 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2362 let current_index = <ItemListIndex>::get(collection_id)2363 .checked_add(1)2364 .unwrap();23652366 let item_owner = item.owner.clone();2367 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23682369 <ItemListIndex>::insert(collection_id, current_index);23702371 2372 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2373 .checked_add(1)2374 .unwrap();2375 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2376 }23772378 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2379 let current_index = <ItemListIndex>::get(collection_id)2380 .checked_add(1)2381 .unwrap();23822383 Self::add_token_index(collection_id, current_index, owner).unwrap();23842385 <ItemListIndex>::insert(collection_id, current_index);23862387 2388 let new_balance = <Balance<T>>::get(collection_id, owner)2389 .checked_add(item.value)2390 .unwrap();2391 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2392 }23932394 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2395 let current_index = <ItemListIndex>::get(collection_id)2396 .checked_add(1)2397 .unwrap();23982399 let value = item.owner.first().unwrap().fraction;2400 let owner = item.owner.first().unwrap().owner.clone();24012402 Self::add_token_index(collection_id, current_index, &owner).unwrap();24032404 <ItemListIndex>::insert(collection_id, current_index);24052406 2407 let new_balance = <Balance<T>>::get(collection_id, &owner)2408 .checked_add(value)2409 .unwrap();2410 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2411 }24122413 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2414 2415 if <AccountItemCount<T>>::contains_key(owner) {24162417 2418 let count = <AccountItemCount<T>>::get(owner);2419 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24202421 <AccountItemCount<T>>::insert(owner.clone(), count2422 .checked_add(1)2423 .ok_or(Error::<T>::NumOverflow)?);2424 }2425 else {2426 <AccountItemCount<T>>::insert(owner.clone(), 1);2427 }24282429 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2430 if list_exists {2431 let mut list = <AddressTokens<T>>::get(collection_id, owner);2432 let item_contains = list.contains(&item_index.clone());24332434 if !item_contains {2435 list.push(item_index.clone());2436 }24372438 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2439 } else {2440 let mut itm = Vec::new();2441 itm.push(item_index.clone());2442 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2443 }24442445 Ok(())2446 }24472448 fn remove_token_index(2449 collection_id: CollectionId,2450 item_index: TokenId,2451 owner: &T::AccountId,2452 ) -> DispatchResult {24532454 2455 <AccountItemCount<T>>::insert(owner.clone(), 2456 <AccountItemCount<T>>::get(owner)2457 .checked_sub(1)2458 .ok_or(Error::<T>::NumOverflow)?);245924602461 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2462 if list_exists {2463 let mut list = <AddressTokens<T>>::get(collection_id, owner);2464 let item_contains = list.contains(&item_index.clone());24652466 if item_contains {2467 list.retain(|&item| item != item_index);2468 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2469 }2470 }24712472 Ok(())2473 }24742475 fn move_token_index(2476 collection_id: CollectionId,2477 item_index: TokenId,2478 old_owner: &T::AccountId,2479 new_owner: &T::AccountId,2480 ) -> DispatchResult {2481 Self::remove_token_index(collection_id, item_index, old_owner)?;2482 Self::add_token_index(collection_id, item_index, new_owner)?;24832484 Ok(())2485 }2486 2487 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2488 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24892490 Ok(())2491 }2492}2493249424952496249724982499pub type Multiplier = FixedU128;25002501type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;2502250325042505#[derive(Encode, Decode, Clone, Eq, PartialEq)]2506pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25072508impl<T: Config + Send + Sync> sp_std::fmt::Debug 2509 for ChargeTransactionPayment<T>2510{2511 #[cfg(feature = "std")]2512 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2513 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2514 }2515 #[cfg(not(feature = "std"))]2516 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2517 Ok(())2518 }2519}25202521impl<T: Config> ChargeTransactionPayment<T>2522where2523 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2524 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2525 T::AccountId: AsRef<[u8]>,2526 T::AccountId: UncheckedFrom<T::Hash>,2527{2528 fn traditional_fee(2529 len: usize,2530 info: &DispatchInfoOf<T::Call>,2531 tip: BalanceOf<T>,2532 ) -> BalanceOf<T>2533 where2534 T::Call: Dispatchable<Info = DispatchInfo>,2535 {2536 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2537 }25382539 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2540 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2541 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2542 let len_saturation = max_block_length as u64 / (len as u64).max(1);2543 let coefficient: BalanceOf<T> = weight_saturation2544 .min(len_saturation)2545 .saturated_into::<BalanceOf<T>>();2546 final_fee2547 .saturating_mul(coefficient)2548 .saturated_into::<TransactionPriority>()2549 }25502551 fn withdraw_fee(2552 &self,2553 who: &T::AccountId,2554 call: &T::Call,2555 info: &DispatchInfoOf<T::Call>,2556 len: usize,2557 ) -> Result<2558 (2559 BalanceOf<T>,2560 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2561 ),2562 TransactionValidityError,2563 > {2564 let tip = self.0;25652566 let fee = Self::traditional_fee(len, info, tip);25672568 2569 if fee.is_zero() {2570 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2571 .map(|i| (fee, i));2572 }25732574 2575 2576 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2577 Some(Call::create_item(collection_id, _owner, _properties)) => {2578 let collection = <CollectionById<T>>::get(collection_id)?;25792580 2581 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25822583 let limit = collection.limits.sponsor_transfer_timeout;2584 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2585 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2586 let limit_time = last_tx_block + limit.into();2587 if block_number <= limit_time {2588 return None;2589 }2590 }2591 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25922593 2594 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2595 collection.sponsorship.sponsor()2596 .cloned()2597 } else {2598 None2599 }2600 }2601 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2602 let collection = <CollectionById<T>>::get(collection_id)?;2603 2604 let mut sponsor_transfer = false;2605 if collection.sponsorship.confirmed() {26062607 let collection_limits = collection.limits;2608 let collection_mode = collection.mode;2609 2610 2611 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2612 sponsor_transfer = match collection_mode {2613 CollectionMode::NFT => {2614 2615 2616 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2617 collection_limits.sponsor_transfer_timeout2618 } else {2619 ChainLimit::get().nft_sponsor_transfer_timeout2620 };2621 2622 let mut sponsored = true;2623 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2624 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2625 let limit_time = last_tx_block + limit.into();2626 if block_number <= limit_time {2627 sponsored = false;2628 }2629 }2630 if sponsored {2631 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2632 }26332634 sponsored2635 }2636 CollectionMode::Fungible(_) => {2637 2638 2639 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2640 collection_limits.sponsor_transfer_timeout2641 } else {2642 ChainLimit::get().fungible_sponsor_transfer_timeout2643 };2644 2645 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2646 let mut sponsored = true;2647 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2648 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2649 let limit_time = last_tx_block + limit.into();2650 if block_number <= limit_time {2651 sponsored = false;2652 }2653 }2654 if sponsored {2655 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2656 }26572658 sponsored2659 }2660 CollectionMode::ReFungible => {2661 2662 2663 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2664 collection_limits.sponsor_transfer_timeout2665 } else {2666 ChainLimit::get().refungible_sponsor_transfer_timeout2667 };2668 2669 let mut sponsored = true;2670 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2671 let last_tx_block = <ReFungibleTransferBasket<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 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2679 }26802681 sponsored2682 }2683 _ => {2684 false2685 },2686 };2687 }26882689 if !sponsor_transfer {2690 None2691 } else {2692 collection.sponsorship.sponsor()2693 .cloned()2694 }2695 }26962697 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2698 let mut sponsor_metadata_changes = false;26992700 let collection = <CollectionById<T>>::get(collection_id)?;27012702 if2703 collection.sponsorship.confirmed() &&2704 2705 2706 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2707 data.len() <= collection.limits.sponsored_data_size as usize2708 {2709 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2710 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27112712 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2713 .map(|last_block| block_number - last_block > rate_limit)2714 .unwrap_or(true) 2715 {2716 sponsor_metadata_changes = true;2717 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2718 }2719 }2720 }27212722 if !sponsor_metadata_changes {2723 None2724 } else {2725 collection.sponsorship.sponsor().cloned()2726 }2727 }27282729 _ => None,2730 })();27312732 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2733 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27342735 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27362737 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2738 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2739 2740 if !owned_contract && white_list_enabled {2741 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2742 return Err(InvalidTransaction::Call.into());2743 }2744 }2745 },2746 _ => {},2747 }27482749 2750 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27512752 2753 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27542755 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2756 &who,2757 code_hash,2758 salt,2759 );2760 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27612762 None2763 },27642765 2766 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27672768 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2769 &who,2770 &T::Hashing::hash(&_code),2771 _salt,2772 );27732774 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27752776 None2777 }27782779 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 mut sponsor_transfer = false;2785 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2786 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2787 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2788 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2789 let limit_time = last_tx_block + rate_limit;27902791 if block_number >= limit_time {2792 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2793 sponsor_transfer = true;2794 }2795 } else {2796 sponsor_transfer = false;2797 }2798 2799 if sponsor_transfer {2800 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2801 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2802 return Some(called_contract);2803 }2804 }2805 }28062807 None2808 },28092810 _ => None,2811 });28122813 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28142815 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2816 .map(|i| (fee, i))2817 }2818}281928202821impl<T: Config + Send + Sync> SignedExtension2822 for ChargeTransactionPayment<T>2823where2824 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2825 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2826 T::AccountId: AsRef<[u8]>,2827 T::AccountId: UncheckedFrom<T::Hash>,2828{2829 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2830 type AccountId = T::AccountId;2831 type Call = T::Call;2832 type AdditionalSigned = ();2833 type Pre = (2834 2835 BalanceOf<T>,2836 2837 Self::AccountId,2838 2839 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2840 );2841 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2842 Ok(())2843 }28442845 fn validate(2846 &self,2847 who: &Self::AccountId,2848 call: &Self::Call,2849 info: &DispatchInfoOf<Self::Call>,2850 len: usize,2851 ) -> TransactionValidity {2852 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2853 Ok(ValidTransaction {2854 priority: Self::get_priority(len, info, fee),2855 ..Default::default()2856 })2857 }28582859 fn pre_dispatch(2860 self,2861 who: &Self::AccountId,2862 call: &Self::Call,2863 info: &DispatchInfoOf<Self::Call>,2864 len: usize,2865 ) -> Result<Self::Pre, TransactionValidityError> {2866 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2867 Ok((self.0, who.clone(), imbalance))2868 }28692870 fn post_dispatch(2871 pre: Self::Pre,2872 info: &DispatchInfoOf<Self::Call>,2873 post_info: &PostDispatchInfoOf<Self::Call>,2874 len: usize,2875 _result: &DispatchResult,2876 ) -> Result<(), TransactionValidityError> {2877 let (tip, who, imbalance) = pre;2878 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2879 len as u32,2880 info,2881 post_info,2882 tip,2883 );2884 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2885 Ok(())2886 }2887}2888288928902891sp_api::decl_runtime_apis! {2892 pub trait NftApi {2893 2894 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2895 }2896}