difftreelog
Fix fee sanity test
in: master
2 files changed
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![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 codec::{Decode, Encode};17pub use frame_support::{18 construct_runtime, decl_event, decl_module, decl_storage, decl_error,19 dispatch::DispatchResult,20 ensure, fail, parameter_types,21 traits::{22 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23 Randomness, IsSubType, WithdrawReasons,24 },25 weights::{26 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28 WeightToFeePolynomial, DispatchClass,29 },30 StorageValue,31 transactional,32};3334use frame_system::{self as system, ensure_signed, ensure_root};35use sp_runtime::sp_std::prelude::Vec;36use sp_runtime::{37 traits::{38 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,39 },40 transaction_validity::{41 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,42 },43 FixedPointOperand, FixedU128,44};45use sp_runtime::traits::StaticLookup;46use pallet_contracts::chain_extension::UncheckedFrom;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;5657pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;58pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;59pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;60pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6162// Structs63// #region6465pub type CollectionId = u32;66pub type TokenId = u32;67pub type DecimalPoints = u8;6869#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]70#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]71pub enum CollectionMode {72 Invalid,73 NFT,74 // decimal points75 Fungible(DecimalPoints),76 ReFungible,77}7879impl Default for CollectionMode {80 fn default() -> Self {81 Self::Invalid82 }83}8485impl Into<u8> for CollectionMode {86 fn into(self) -> u8 {87 match self {88 CollectionMode::Invalid => 0,89 CollectionMode::NFT => 1,90 CollectionMode::Fungible(_) => 2,91 CollectionMode::ReFungible => 3,92 }93 }94}9596#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]97#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]98pub enum AccessMode {99 Normal,100 WhiteList,101}102impl Default for AccessMode {103 fn default() -> Self {104 Self::Normal105 }106}107108#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]109#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]110pub enum SchemaVersion {111 ImageURL,112 Unique,113}114impl Default for SchemaVersion {115 fn default() -> Self {116 Self::ImageURL117 }118}119120#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]121#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]122pub struct Ownership<AccountId> {123 pub owner: AccountId,124 pub fraction: u128,125}126127#[derive(Encode, Decode, Debug, Clone, PartialEq)]128#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]129pub enum SponsorshipState<AccountId> {130 /// The fees are applied to the transaction sender131 Disabled,132 Unconfirmed(AccountId),133 /// Transactions are sponsored by specified account134 Confirmed(AccountId),135}136137impl<AccountId> SponsorshipState<AccountId> {138 fn sponsor(&self) -> Option<&AccountId> {139 match self {140 Self::Confirmed(sponsor) => Some(sponsor),141 _ => None,142 }143 }144145 fn pending_sponsor(&self) -> Option<&AccountId> {146 match self {147 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),148 _ => None,149 }150 }151152 fn confirmed(&self) -> bool {153 matches!(self, Self::Confirmed(_))154 }155}156157impl<T> Default for SponsorshipState<T> {158 fn default() -> Self {159 Self::Disabled160 }161}162163#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]164#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]165pub struct CollectionType<AccountId> {166 pub owner: AccountId,167 pub mode: CollectionMode,168 pub access: AccessMode,169 pub decimal_points: DecimalPoints,170 pub name: Vec<u16>, // 64 include null escape char171 pub description: Vec<u16>, // 256 include null escape char172 pub token_prefix: Vec<u8>, // 16 include null escape char173 pub mint_mode: bool,174 pub offchain_schema: Vec<u8>,175 pub schema_version: SchemaVersion,176 pub sponsorship: SponsorshipState<AccountId>,177 pub limits: CollectionLimits, // Collection private restrictions 178 pub variable_on_chain_schema: Vec<u8>, //179 pub const_on_chain_schema: Vec<u8>, //180}181182#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]183#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]184pub struct NftItemType<AccountId> {185 pub owner: AccountId,186 pub const_data: Vec<u8>,187 pub variable_data: Vec<u8>,188}189190#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]191#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]192pub struct FungibleItemType {193 pub value: u128,194}195196#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]197#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]198pub struct ReFungibleItemType<AccountId> {199 pub owner: Vec<Ownership<AccountId>>,200 pub const_data: Vec<u8>,201 pub variable_data: Vec<u8>,202}203204// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]205// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206// pub struct VestingItem<AccountId, Moment> {207// pub sender: AccountId,208// pub recipient: AccountId,209// pub collection_id: CollectionId,210// pub item_id: TokenId,211// pub amount: u64,212// pub vesting_date: Moment,213// }214215#[derive(Encode, Decode, Debug, Clone, PartialEq)]216#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]217pub struct CollectionLimits {218 pub account_token_ownership_limit: u32,219 pub sponsored_data_size: u32,220 pub token_limit: u32,221222 // Timeouts for item types in passed blocks223 pub sponsor_transfer_timeout: u32,224 pub owner_can_transfer: bool,225 pub owner_can_destroy: bool,226}227228impl Default for CollectionLimits {229 fn default() -> CollectionLimits {230 CollectionLimits { 231 account_token_ownership_limit: 10_000_000, 232 token_limit: u32::max_value(),233 sponsored_data_size: u32::MAX,234 sponsor_transfer_timeout: 14400,235 owner_can_transfer: true,236 owner_can_destroy: true237 }238 }239}240241#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]242#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]243pub struct ChainLimits {244 pub collection_numbers_limit: u32,245 pub account_token_ownership_limit: u32,246 pub collections_admins_limit: u64,247 pub custom_data_limit: u32,248249 // Timeouts for item types in passed blocks250 pub nft_sponsor_transfer_timeout: u32,251 pub fungible_sponsor_transfer_timeout: u32,252 pub refungible_sponsor_transfer_timeout: u32,253254 // Schema limits255 pub offchain_schema_limit: u32,256 pub variable_on_chain_schema_limit: u32,257 pub const_on_chain_schema_limit: u32,258}259260pub trait WeightInfo {261 fn create_collection() -> Weight;262 fn destroy_collection() -> Weight;263 fn add_to_white_list() -> Weight;264 fn remove_from_white_list() -> Weight;265 fn set_public_access_mode() -> Weight;266 fn set_mint_permission() -> Weight;267 fn change_collection_owner() -> Weight;268 fn add_collection_admin() -> Weight;269 fn remove_collection_admin() -> Weight;270 fn set_collection_sponsor() -> Weight;271 fn confirm_sponsorship() -> Weight;272 fn remove_collection_sponsor() -> Weight;273 fn create_item(s: usize) -> Weight;274 fn burn_item() -> Weight;275 fn transfer() -> Weight;276 fn approve() -> Weight;277 fn transfer_from() -> Weight;278 fn set_offchain_schema() -> Weight;279 fn set_const_on_chain_schema() -> Weight;280 fn set_variable_on_chain_schema() -> Weight;281 fn set_variable_meta_data() -> Weight;282 fn enable_contract_sponsoring() -> Weight;283 fn set_schema_version() -> Weight;284 fn set_chain_limits() -> Weight;285 fn set_contract_sponsoring_rate_limit() -> Weight;286 fn toggle_contract_white_list() -> Weight;287 fn add_to_contract_white_list() -> Weight;288 fn remove_from_contract_white_list() -> Weight;289 fn set_collection_limits() -> Weight;290}291292#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]293#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]294pub struct CreateNftData {295 pub const_data: Vec<u8>,296 pub variable_data: Vec<u8>,297}298299#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]300#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]301pub struct CreateFungibleData {302 pub value: u128,303}304305#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]306#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]307pub struct CreateReFungibleData {308 pub const_data: Vec<u8>,309 pub variable_data: Vec<u8>,310 pub pieces: u128,311}312313#[derive(Encode, Decode, Debug, Clone, PartialEq)]314#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]315pub enum CreateItemData {316 NFT(CreateNftData),317 Fungible(CreateFungibleData),318 ReFungible(CreateReFungibleData),319}320321impl CreateItemData {322 pub fn len(&self) -> usize {323 let len = match self {324 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),325 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),326 _ => 0327 };328 329 return len;330 }331}332333impl From<CreateNftData> for CreateItemData {334 fn from(item: CreateNftData) -> Self {335 CreateItemData::NFT(item)336 }337}338339impl From<CreateReFungibleData> for CreateItemData {340 fn from(item: CreateReFungibleData) -> Self {341 CreateItemData::ReFungible(item)342 }343}344345impl From<CreateFungibleData> for CreateItemData {346 fn from(item: CreateFungibleData) -> Self {347 CreateItemData::Fungible(item)348 }349}350351352decl_error! {353 /// Error for non-fungible-token module.354 pub enum Error for Module<T: Config> {355 /// Total collections bound exceeded.356 TotalCollectionsLimitExceeded,357 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.358 CollectionDecimalPointLimitExceeded, 359 /// Collection name can not be longer than 63 char.360 CollectionNameLimitExceeded, 361 /// Collection description can not be longer than 255 char.362 CollectionDescriptionLimitExceeded, 363 /// Token prefix can not be longer than 15 char.364 CollectionTokenPrefixLimitExceeded,365 /// This collection does not exist.366 CollectionNotFound,367 /// Item not exists.368 TokenNotFound,369 /// Admin not found370 AdminNotFound,371 /// Arithmetic calculation overflow.372 NumOverflow, 373 /// Account already has admin role.374 AlreadyAdmin, 375 /// You do not own this collection.376 NoPermission,377 /// This address is not set as sponsor, use setCollectionSponsor first.378 ConfirmUnsetSponsorFail,379 /// Collection is not in mint mode.380 PublicMintingNotAllowed,381 /// Sender parameter and item owner must be equal.382 MustBeTokenOwner,383 /// Item balance not enough.384 TokenValueTooLow,385 /// Size of item is too large.386 NftSizeLimitExceeded,387 /// No approve found388 ApproveNotFound,389 /// Requested value more than approved.390 TokenValueNotEnough,391 /// Only approved addresses can call this method.392 ApproveRequired,393 /// Address is not in white list.394 AddresNotInWhiteList,395 /// Number of collection admins bound exceeded.396 CollectionAdminsLimitExceeded,397 /// Owned tokens by a single address bound exceeded.398 AddressOwnershipLimitExceeded,399 /// Length of items properties must be greater than 0.400 EmptyArgument,401 /// const_data exceeded data limit.402 TokenConstDataLimitExceeded,403 /// variable_data exceeded data limit.404 TokenVariableDataLimitExceeded,405 /// Not NFT item data used to mint in NFT collection.406 NotNftDataUsedToMintNftCollectionToken,407 /// Not Fungible item data used to mint in Fungible collection.408 NotFungibleDataUsedToMintFungibleCollectionToken,409 /// Not Re Fungible item data used to mint in Re Fungible collection.410 NotReFungibleDataUsedToMintReFungibleCollectionToken,411 /// Unexpected collection type.412 UnexpectedCollectionType,413 /// Can't store metadata in fungible tokens.414 CantStoreMetadataInFungibleTokens,415 /// Collection token limit exceeded416 CollectionTokenLimitExceeded,417 /// Account token limit exceeded per collection418 AccountTokenLimitExceeded,419 /// Collection limit bounds per collection exceeded420 CollectionLimitBoundsExceeded,421 /// Tried to enable permissions which are only permitted to be disabled422 OwnerPermissionsCantBeReverted,423 /// Schema data size limit bound exceeded424 SchemaDataLimitExceeded,425 /// Maximum refungibility exceeded426 WrongRefungiblePieces,427 /// createRefungible should be called with one owner428 BadCreateRefungibleCall,429 }430}431432pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {433 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;434435 /// Weight information for extrinsics in this pallet.436 type WeightInfo: WeightInfo;437438 type Currency: Currency<Self::AccountId>;439 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;440 type TreasuryAccountId: Get<Self::AccountId>;441}442443#[cfg(feature = "runtime-benchmarks")]444mod benchmarking;445446// #endregion447448// # Used definitions449//450// ## User control levels451//452// chain-controlled - key is uncontrolled by user453// i.e autoincrementing index454// can use non-cryptographic hash455// real - key is controlled by user456// but it is hard to generate enough colliding values, i.e owner of signed txs457// can use non-cryptographic hash458// controlled - key is completly controlled by users459// i.e maps with mutable keys460// should use cryptographic hash461//462// ## User control level downgrade reasons463//464// ?1 - chain-controlled -> controlled465// collections/tokens can be destroyed, resulting in massive holes466// ?2 - chain-controlled -> controlled467// same as ?1, but can be only added, resulting in easier exploitation468// ?3 - real -> controlled469// no confirmation required, so addresses can be easily generated470decl_storage! {471 trait Store for Module<T: Config> as Nft {472473 //#region Private members474 /// Id of next collection475 CreatedCollectionCount: u32;476 /// Used for migrations477 ChainVersion: u64;478 /// Id of last collection token479 /// Collection id (controlled?1)480 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;481 //#endregion482483 //#region Chain limits struct484 pub ChainLimit get(fn chain_limit) config(): ChainLimits;485 //#endregion486487 //#region Bound counters488 /// Amount of collections destroyed, used for total amount tracking with489 /// CreatedCollectionCount490 DestroyedCollectionCount: u32;491 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)492 /// Account id (real)493 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;494 //#endregion495496 //#region Basic collections497 /// Collection info498 /// Collection id (controlled?1)499 pub Collection get(fn collection) config(): map hasher(blake2_128_concat) CollectionId => CollectionType<T::AccountId>;500 /// List of collection admins501 /// Collection id (controlled?2)502 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;503 /// Whitelisted collection users504 /// Collection id (controlled?2), user id (controlled?3)505 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;506 //#endregion507508 /// How many of collection items user have509 /// Collection id (controlled?2), account id (real)510 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;511512 /// Amount of items which spender can transfer out of owners account (via transferFrom)513 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))514 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;515516 //#region Item collections517 /// Collection id (controlled?2), token id (controlled?1)518 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;519 /// Collection id (controlled?2), owner (controlled?2)520 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;521 /// Collection id (controlled?2), token id (controlled?1)522 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;523 //#endregion524525 //#region Index list526 /// Collection id (controlled?2), tokens owner (controlled?2)527 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;528 //#endregion529530 //#region Tokens transfer rate limit baskets531 /// (Collection id (controlled?2), who created (real))532 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;533 /// Collection id (controlled?2), token id (controlled?2)534 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;535 /// Collection id (controlled?2), owning user (real)536 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;537 /// Collection id (controlled?2), token id (controlled?2)538 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;539 //#endregion540541 //#region Contract Sponsorship and Ownership542 /// Contract address (real)543 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;544 /// Contract address (real)545 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;546 /// (Contract address(real), caller (real))547 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;548 /// Contract address (real)549 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;550 /// Contract address (real)551 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 552 /// Contract address (real) => Whitelisted user (controlled?3)553 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 554 //#endregion555 }556 add_extra_genesis {557 build(|config: &GenesisConfig<T>| {558 // Modification of storage559 for (_num, _c) in &config.collection {560 <Module<T>>::init_collection(_c);561 }562563 for (_num, _c, _i) in &config.nft_item_id {564 <Module<T>>::init_nft_token(*_c, _i);565 }566567 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {568 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);569 }570571 for (_num, _c, _i) in &config.refungible_item_id {572 <Module<T>>::init_refungible_token(*_c, _i);573 }574 })575 }576}577578decl_event!(579 pub enum Event<T>580 where581 AccountId = <T as system::Config>::AccountId,582 {583 /// New collection was created584 /// 585 /// # Arguments586 /// 587 /// * collection_id: Globally unique identifier of newly created collection.588 /// 589 /// * mode: [CollectionMode] converted into u8.590 /// 591 /// * account_id: Collection owner.592 Created(CollectionId, u8, AccountId),593594 /// New item was created.595 /// 596 /// # Arguments597 /// 598 /// * collection_id: Id of the collection where item was created.599 /// 600 /// * item_id: Id of an item. Unique within the collection.601 ///602 /// * recipient: Owner of newly created item 603 ItemCreated(CollectionId, TokenId, AccountId),604605 /// Collection item was burned.606 /// 607 /// # Arguments608 /// 609 /// collection_id.610 /// 611 /// item_id: Identifier of burned NFT.612 ItemDestroyed(CollectionId, TokenId),613614 /// Item was transferred615 ///616 /// * collection_id: Id of collection to which item is belong617 ///618 /// * item_id: Id of an item619 ///620 /// * sender: Original owner of item621 ///622 /// * recipient: New owner of item623 ///624 /// * amount: Always 1 for NFT625 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),626 }627);628629decl_module! {630 pub struct Module<T: Config> for enum Call 631 where 632 origin: T::Origin633 {634 fn deposit_event() = default;635 type Error = Error<T>;636637 fn on_initialize(now: T::BlockNumber) -> Weight {638 0639 }640641 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.642 /// 643 /// # Permissions644 /// 645 /// * Anyone.646 /// 647 /// # Arguments648 /// 649 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.650 /// 651 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.652 /// 653 /// * token_prefix: UTF-8 string with token prefix.654 /// 655 /// * mode: [CollectionMode] collection type and type dependent data.656 // returns collection ID657 #[weight = <T as Config>::WeightInfo::create_collection()]658 #[transactional]659 pub fn create_collection(origin,660 collection_name: Vec<u16>,661 collection_description: Vec<u16>,662 token_prefix: Vec<u8>,663 mode: CollectionMode) -> DispatchResult {664665 // Anyone can create a collection666 let who = ensure_signed(origin)?;667668 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();669 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(670 &T::TreasuryAccountId::get(),671 T::CollectionCreationPrice::get(),672 ));673 <T as Config>::Currency::settle(674 &who,675 imbalance,676 WithdrawReasons::TRANSFER,677 ExistenceRequirement::KeepAlive,678 ).map_err(|_| Error::<T>::NoPermission)?;679680 let decimal_points = match mode {681 CollectionMode::Fungible(points) => points,682 _ => 0683 };684685 let chain_limit = ChainLimit::get();686687 let created_count = CreatedCollectionCount::get();688 let destroyed_count = DestroyedCollectionCount::get();689690 // bound Total number of collections691 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);692693 // check params694 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);695 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);696 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);697 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);698699 // Generate next collection ID700 let next_id = created_count701 .checked_add(1)702 .ok_or(Error::<T>::NumOverflow)?;703704 CreatedCollectionCount::put(next_id);705706 let limits = CollectionLimits {707 sponsored_data_size: chain_limit.custom_data_limit,708 ..Default::default()709 };710711 // Create new collection712 let new_collection = CollectionType {713 owner: who.clone(),714 name: collection_name,715 mode: mode.clone(),716 mint_mode: false,717 access: AccessMode::Normal,718 description: collection_description,719 decimal_points: decimal_points,720 token_prefix: token_prefix,721 offchain_schema: Vec::new(),722 schema_version: SchemaVersion::ImageURL,723 sponsorship: SponsorshipState::Disabled,724 variable_on_chain_schema: Vec::new(),725 const_on_chain_schema: Vec::new(),726 limits,727 };728729 // Add new collection to map730 <Collection<T>>::insert(next_id, new_collection);731732 // call event733 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));734735 Ok(())736 }737738 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.739 /// 740 /// # Permissions741 /// 742 /// * Collection Owner.743 /// 744 /// # Arguments745 /// 746 /// * collection_id: collection to destroy.747 #[weight = <T as Config>::WeightInfo::destroy_collection()]748 #[transactional]749 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {750751 let sender = ensure_signed(origin)?;752 Self::check_owner_permissions(collection_id, sender)?;753754 let target_collection = <Collection<T>>::get(collection_id);755 if !target_collection.limits.owner_can_destroy {756 fail!(Error::<T>::NoPermission);757 }758759 <AddressTokens<T>>::remove_prefix(collection_id);760 <Allowances<T>>::remove_prefix(collection_id);761 <Balance<T>>::remove_prefix(collection_id);762 <ItemListIndex>::remove(collection_id);763 <AdminList<T>>::remove(collection_id);764 <Collection<T>>::remove(collection_id);765 <WhiteList<T>>::remove_prefix(collection_id);766767 <NftItemList<T>>::remove_prefix(collection_id);768 <FungibleItemList<T>>::remove_prefix(collection_id);769 <ReFungibleItemList<T>>::remove_prefix(collection_id);770771 <NftTransferBasket<T>>::remove_prefix(collection_id);772 <FungibleTransferBasket<T>>::remove_prefix(collection_id);773 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);774775 DestroyedCollectionCount::put(DestroyedCollectionCount::get()776 .checked_add(1)777 .ok_or(Error::<T>::NumOverflow)?);778779 Ok(())780 }781782 /// Add an address to white list.783 /// 784 /// # Permissions785 /// 786 /// * Collection Owner787 /// * Collection Admin788 /// 789 /// # Arguments790 /// 791 /// * collection_id.792 /// 793 /// * address.794 #[weight = <T as Config>::WeightInfo::add_to_white_list()]795 #[transactional]796 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{797798 let sender = ensure_signed(origin)?;799 Self::check_owner_or_admin_permissions(collection_id, sender)?;800801 <WhiteList<T>>::insert(collection_id, address, true);802 803 Ok(())804 }805806 /// Remove an address from white list.807 /// 808 /// # Permissions809 /// 810 /// * Collection Owner811 /// * Collection Admin812 /// 813 /// # Arguments814 /// 815 /// * collection_id.816 /// 817 /// * address.818 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]819 #[transactional]820 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{821822 let sender = ensure_signed(origin)?;823 Self::check_owner_or_admin_permissions(collection_id, sender)?;824825 <WhiteList<T>>::remove(collection_id, address);826827 Ok(())828 }829830 /// Toggle between normal and white list access for the methods with access for `Anyone`.831 /// 832 /// # Permissions833 /// 834 /// * Collection Owner.835 /// 836 /// # Arguments837 /// 838 /// * collection_id.839 /// 840 /// * mode: [AccessMode]841 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]842 #[transactional]843 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult844 {845 let sender = ensure_signed(origin)?;846847 Self::check_owner_permissions(collection_id, sender)?;848 let mut target_collection = <Collection<T>>::get(collection_id);849 target_collection.access = mode;850 <Collection<T>>::insert(collection_id, target_collection);851852 Ok(())853 }854855 /// Allows Anyone to create tokens if:856 /// * White List is enabled, and857 /// * Address is added to white list, and858 /// * This method was called with True parameter859 /// 860 /// # Permissions861 /// * Collection Owner862 ///863 /// # Arguments864 /// 865 /// * collection_id.866 /// 867 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.868 #[weight = <T as Config>::WeightInfo::set_mint_permission()]869 #[transactional]870 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult871 {872 let sender = ensure_signed(origin)?;873874 Self::check_owner_permissions(collection_id, sender)?;875 let mut target_collection = <Collection<T>>::get(collection_id);876 target_collection.mint_mode = mint_permission;877 <Collection<T>>::insert(collection_id, target_collection);878879 Ok(())880 }881882 /// Change the owner of the collection.883 /// 884 /// # Permissions885 /// 886 /// * Collection Owner.887 /// 888 /// # Arguments889 /// 890 /// * collection_id.891 /// 892 /// * new_owner.893 #[weight = <T as Config>::WeightInfo::change_collection_owner()]894 #[transactional]895 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {896897 let sender = ensure_signed(origin)?;898 Self::check_owner_permissions(collection_id, sender)?;899 let mut target_collection = <Collection<T>>::get(collection_id);900 target_collection.owner = new_owner;901 <Collection<T>>::insert(collection_id, target_collection);902903 Ok(())904 }905906 /// Adds an admin of the Collection.907 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 908 /// 909 /// # Permissions910 /// 911 /// * Collection Owner.912 /// * Collection Admin.913 /// 914 /// # Arguments915 /// 916 /// * collection_id: ID of the Collection to add admin for.917 /// 918 /// * new_admin_id: Address of new admin to add.919 #[weight = <T as Config>::WeightInfo::add_collection_admin()]920 #[transactional]921 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {922923 let sender = ensure_signed(origin)?;924 Self::check_owner_or_admin_permissions(collection_id, sender)?;925 let mut admin_arr: Vec<T::AccountId> = Vec::new();926927 if <AdminList<T>>::contains_key(collection_id)928 {929 admin_arr = <AdminList<T>>::get(collection_id);930 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);931 }932933 // Number of collection admins934 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);935936 admin_arr.push(new_admin_id);937 <AdminList<T>>::insert(collection_id, admin_arr);938939 Ok(())940 }941942 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.943 ///944 /// # Permissions945 /// 946 /// * Collection Owner.947 /// * Collection Admin.948 /// 949 /// # Arguments950 /// 951 /// * collection_id: ID of the Collection to remove admin for.952 /// 953 /// * account_id: Address of admin to remove.954 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]955 #[transactional]956 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {957958 let sender = ensure_signed(origin)?;959 Self::check_owner_or_admin_permissions(collection_id, sender)?;960 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);961962 let mut admin_arr = <AdminList<T>>::get(collection_id);963 admin_arr.retain(|i| *i != account_id);964 <AdminList<T>>::insert(collection_id, admin_arr);965966 Ok(())967 }968969 /// # Permissions970 /// 971 /// * Collection Owner972 /// 973 /// # Arguments974 /// 975 /// * collection_id.976 /// 977 /// * new_sponsor.978 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]979 #[transactional]980 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {981982 let sender = ensure_signed(origin)?;983 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);984985 let mut target_collection = <Collection<T>>::get(collection_id);986 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);987988 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);989 <Collection<T>>::insert(collection_id, target_collection);990991 Ok(())992 }993994 /// # Permissions995 /// 996 /// * Sponsor.997 /// 998 /// # Arguments999 /// 1000 /// * collection_id.1001 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1002 #[transactional]1003 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10041005 let sender = ensure_signed(origin)?;1006 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10071008 let mut target_collection = <Collection<T>>::get(collection_id);1009 ensure!(1010 target_collection.sponsorship.pending_sponsor() == Some(&sender),1011 Error::<T>::ConfirmUnsetSponsorFail1012 );10131014 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1015 <Collection<T>>::insert(collection_id, target_collection);10161017 Ok(())1018 }10191020 /// Switch back to pay-per-own-transaction model.1021 ///1022 /// # Permissions1023 ///1024 /// * Collection owner.1025 /// 1026 /// # Arguments1027 /// 1028 /// * collection_id.1029 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1030 #[transactional]1031 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10321033 let sender = ensure_signed(origin)?;1034 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10351036 let mut target_collection = <Collection<T>>::get(collection_id);1037 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10381039 target_collection.sponsorship = SponsorshipState::Disabled;1040 <Collection<T>>::insert(collection_id, target_collection);10411042 Ok(())1043 }10441045 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1046 /// 1047 /// # Permissions1048 /// 1049 /// * Collection Owner.1050 /// * Collection Admin.1051 /// * Anyone if1052 /// * White List is enabled, and1053 /// * Address is added to white list, and1054 /// * MintPermission is enabled (see SetMintPermission method)1055 /// 1056 /// # Arguments1057 /// 1058 /// * collection_id: ID of the collection.1059 /// 1060 /// * owner: Address, initial owner of the NFT.1061 ///1062 /// * data: Token data to store on chain.1063 // #[weight =1064 // (130_000_000 as Weight)1065 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1066 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1067 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]10681069 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1070 #[transactional]1071 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10721073 let sender = ensure_signed(origin)?;10741075 Self::collection_exists(collection_id)?;10761077 let target_collection = <Collection<T>>::get(collection_id);10781079 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1080 Self::validate_create_item_args(&target_collection, &data)?;1081 Self::create_item_no_validation(collection_id, owner, data)?;10821083 Ok(())1084 }10851086 /// This method creates multiple items in a collection created with CreateCollection method.1087 /// 1088 /// # Permissions1089 /// 1090 /// * Collection Owner.1091 /// * Collection Admin.1092 /// * Anyone if1093 /// * White List is enabled, and1094 /// * Address is added to white list, and1095 /// * MintPermission is enabled (see SetMintPermission method)1096 /// 1097 /// # Arguments1098 /// 1099 /// * collection_id: ID of the collection.1100 /// 1101 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1102 /// 1103 /// * owner: Address, initial owner of the NFT.1104 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1105 .map(|data| { data.len() })1106 .sum())]1107 #[transactional]1108 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11091110 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1111 let sender = ensure_signed(origin)?;11121113 Self::collection_exists(collection_id)?;1114 let target_collection = <Collection<T>>::get(collection_id);11151116 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11171118 for data in &items_data {1119 Self::validate_create_item_args(&target_collection, data)?;1120 }1121 for data in &items_data {1122 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1123 }11241125 Ok(())1126 }11271128 /// Destroys a concrete instance of NFT.1129 /// 1130 /// # Permissions1131 /// 1132 /// * Collection Owner.1133 /// * Collection Admin.1134 /// * Current NFT Owner.1135 /// 1136 /// # Arguments1137 /// 1138 /// * collection_id: ID of the collection.1139 /// 1140 /// * item_id: ID of NFT to burn.1141 #[weight = <T as Config>::WeightInfo::burn_item()]1142 #[transactional]1143 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11441145 let sender = ensure_signed(origin)?;1146 Self::collection_exists(collection_id)?;11471148 // Transfer permissions check1149 let target_collection = <Collection<T>>::get(collection_id);1150 ensure!(1151 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1152 (1153 target_collection.limits.owner_can_transfer &&1154 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1155 ),1156 Error::<T>::NoPermission1157 );11581159 if target_collection.access == AccessMode::WhiteList {1160 Self::check_white_list(collection_id, &sender)?;1161 }11621163 match target_collection.mode1164 {1165 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1166 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1167 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1168 _ => ()1169 };11701171 // call event1172 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11731174 Ok(())1175 }11761177 /// Change ownership of the token.1178 /// 1179 /// # Permissions1180 /// 1181 /// * Collection Owner1182 /// * Collection Admin1183 /// * Current NFT owner1184 ///1185 /// # Arguments1186 /// 1187 /// * recipient: Address of token recipient.1188 /// 1189 /// * collection_id.1190 /// 1191 /// * item_id: ID of the item1192 /// * Non-Fungible Mode: Required.1193 /// * Fungible Mode: Ignored.1194 /// * Re-Fungible Mode: Required.1195 /// 1196 /// * value: Amount to transfer.1197 /// * Non-Fungible Mode: Ignored1198 /// * Fungible Mode: Must specify transferred amount1199 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1200 #[weight = <T as Config>::WeightInfo::transfer()]1201 #[transactional]1202 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1203 let sender = ensure_signed(origin)?;1204 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1205 }12061207 /// Set, change, or remove approved address to transfer the ownership of the NFT.1208 /// 1209 /// # Permissions1210 /// 1211 /// * Collection Owner1212 /// * Collection Admin1213 /// * Current NFT owner1214 /// 1215 /// # Arguments1216 /// 1217 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1218 /// 1219 /// * collection_id.1220 /// 1221 /// * item_id: ID of the item.1222 #[weight = <T as Config>::WeightInfo::approve()]1223 #[transactional]1224 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12251226 let sender = ensure_signed(origin)?;12271228 Self::collection_exists(collection_id)?;1229 Self::token_exists(collection_id, item_id, &sender)?;12301231 // Transfer permissions check1232 let target_collection = <Collection<T>>::get(collection_id);1233 let allowance_limit = if target_collection.limits.owner_can_transfer &&1234 Self::is_owner_or_admin_permissions(1235 collection_id,1236 sender.clone(),1237 ) {1238 None1239 } else if let Some(amount) = Self::owned_amount(1240 sender.clone(),1241 collection_id,1242 item_id,1243 ) {1244 Some(amount)1245 } else {1246 fail!(Error::<T>::NoPermission);1247 };12481249 if target_collection.access == AccessMode::WhiteList {1250 Self::check_white_list(collection_id, &sender)?;1251 Self::check_white_list(collection_id, &spender)?;1252 }12531254 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1255 let mut allowance: u128 = amount;1256 if allowance_exists {1257 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1258 }1259 if let Some(limit) = allowance_limit {1260 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1261 }1262 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12631264 Ok(())1265 }1266 1267 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1268 /// 1269 /// # Permissions1270 /// * Collection Owner1271 /// * Collection Admin1272 /// * Current NFT owner1273 /// * Address approved by current NFT owner1274 /// 1275 /// # Arguments1276 /// 1277 /// * from: Address that owns token.1278 /// 1279 /// * recipient: Address of token recipient.1280 /// 1281 /// * collection_id.1282 /// 1283 /// * item_id: ID of the item.1284 /// 1285 /// * value: Amount to transfer.1286 #[weight = <T as Config>::WeightInfo::transfer_from()]1287 #[transactional]1288 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12891290 let sender = ensure_signed(origin)?;1291 let mut appoved_transfer = false;12921293 // Check approval1294 let mut approval: u128 = 0;1295 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1296 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1297 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1298 appoved_transfer = true;1299 }13001301 let target_collection = <Collection<T>>::get(collection_id);13021303 // Limits check1304 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;13051306 // Transfer permissions check 1307 ensure!(1308 appoved_transfer || 1309 (1310 target_collection.limits.owner_can_transfer &&1311 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1312 ),1313 Error::<T>::NoPermission1314 );13151316 if target_collection.access == AccessMode::WhiteList {1317 Self::check_white_list(collection_id, &sender)?;1318 Self::check_white_list(collection_id, &recipient)?;1319 }13201321 // Reduce approval by transferred amount or remove if remaining approval drops to 01322 if approval.saturating_sub(value) > 0 {1323 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1324 }1325 else {1326 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1327 }13281329 match target_collection.mode1330 {1331 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1332 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1333 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1334 _ => ()1335 };13361337 Ok(())1338 }13391340 // #[weight = 0]1341 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13421343 // // let no_perm_mes = "You do not have permissions to modify this collection";1344 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1345 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1346 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13471348 // // // on_nft_received call13491350 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13511352 // Ok(())1353 // }13541355 /// Set off-chain data schema.1356 /// 1357 /// # Permissions1358 /// 1359 /// * Collection Owner1360 /// * Collection Admin1361 /// 1362 /// # Arguments1363 /// 1364 /// * collection_id.1365 /// 1366 /// * schema: String representing the offchain data schema.1367 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1368 #[transactional]1369 pub fn set_variable_meta_data (1370 origin,1371 collection_id: CollectionId,1372 item_id: TokenId,1373 data: Vec<u8>1374 ) -> DispatchResult {1375 let sender = ensure_signed(origin)?;1376 1377 Self::collection_exists(collection_id)?;1378 Self::token_exists(collection_id, item_id, &sender)?;13791380 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13811382 // Modify permissions check1383 let target_collection = <Collection<T>>::get(collection_id);1384 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1385 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1386 Error::<T>::NoPermission);13871388 match target_collection.mode1389 {1390 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1391 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1392 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1393 _ => fail!(Error::<T>::UnexpectedCollectionType)1394 };13951396 Ok(())1397 }1398 1399 /// Set schema standard1400 /// ImageURL1401 /// Unique1402 /// 1403 /// # Permissions1404 /// 1405 /// * Collection Owner1406 /// * Collection Admin1407 /// 1408 /// # Arguments1409 /// 1410 /// * collection_id.1411 /// 1412 /// * schema: SchemaVersion: enum1413 #[weight = <T as Config>::WeightInfo::set_schema_version()]1414 #[transactional]1415 pub fn set_schema_version(1416 origin,1417 collection_id: CollectionId,1418 version: SchemaVersion1419 ) -> DispatchResult {1420 let sender = ensure_signed(origin)?;1421 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1422 let mut target_collection = <Collection<T>>::get(collection_id);1423 target_collection.schema_version = version;1424 <Collection<T>>::insert(collection_id, target_collection);14251426 Ok(())1427 }14281429 /// Set off-chain data schema.1430 /// 1431 /// # Permissions1432 /// 1433 /// * Collection Owner1434 /// * Collection Admin1435 /// 1436 /// # Arguments1437 /// 1438 /// * collection_id.1439 /// 1440 /// * schema: String representing the offchain data schema.1441 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1442 #[transactional]1443 pub fn set_offchain_schema(1444 origin,1445 collection_id: CollectionId,1446 schema: Vec<u8>1447 ) -> DispatchResult {1448 let sender = ensure_signed(origin)?;1449 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14501451 // check schema limit1452 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14531454 let mut target_collection = <Collection<T>>::get(collection_id);1455 target_collection.offchain_schema = schema;1456 <Collection<T>>::insert(collection_id, target_collection);14571458 Ok(())1459 }14601461 /// Set const on-chain data schema.1462 /// 1463 /// # Permissions1464 /// 1465 /// * Collection Owner1466 /// * Collection Admin1467 /// 1468 /// # Arguments1469 /// 1470 /// * collection_id.1471 /// 1472 /// * schema: String representing the const on-chain data schema.1473 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1474 #[transactional]1475 pub fn set_const_on_chain_schema (1476 origin,1477 collection_id: CollectionId,1478 schema: Vec<u8>1479 ) -> DispatchResult {1480 let sender = ensure_signed(origin)?;1481 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14821483 // check schema limit1484 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14851486 let mut target_collection = <Collection<T>>::get(collection_id);1487 target_collection.const_on_chain_schema = schema;1488 <Collection<T>>::insert(collection_id, target_collection);14891490 Ok(())1491 }14921493 /// Set variable on-chain data schema.1494 /// 1495 /// # Permissions1496 /// 1497 /// * Collection Owner1498 /// * Collection Admin1499 /// 1500 /// # Arguments1501 /// 1502 /// * collection_id.1503 /// 1504 /// * schema: String representing the variable on-chain data schema.1505 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1506 #[transactional]1507 pub fn set_variable_on_chain_schema (1508 origin,1509 collection_id: CollectionId,1510 schema: Vec<u8>1511 ) -> DispatchResult {1512 let sender = ensure_signed(origin)?;1513 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;15141515 // check schema limit1516 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15171518 let mut target_collection = <Collection<T>>::get(collection_id);1519 target_collection.variable_on_chain_schema = schema;1520 <Collection<T>>::insert(collection_id, target_collection);15211522 Ok(())1523 }15241525 // Sudo permissions function1526 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1527 #[transactional]1528 pub fn set_chain_limits(1529 origin,1530 limits: ChainLimits1531 ) -> DispatchResult {15321533 #[cfg(not(feature = "runtime-benchmarks"))]1534 ensure_root(origin)?;15351536 <ChainLimit>::put(limits);1537 Ok(())1538 }15391540 /// Enable smart contract self-sponsoring.1541 /// 1542 /// # Permissions1543 /// 1544 /// * Contract Owner1545 /// 1546 /// # Arguments1547 /// 1548 /// * contract address1549 /// * enable flag1550 /// 1551 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1552 #[transactional]1553 pub fn enable_contract_sponsoring(1554 origin,1555 contract_address: T::AccountId,1556 enable: bool1557 ) -> DispatchResult {15581559 let sender = ensure_signed(origin)?;15601561 #[cfg(feature = "runtime-benchmarks")]1562 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15631564 Self::ensure_contract_owned(sender, &contract_address)?;15651566 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1567 Ok(())1568 }15691570 /// Set the rate limit for contract sponsoring to specified number of blocks.1571 /// 1572 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1573 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1574 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1575 /// from contract endowment if there are at least B blocks between such transactions. 1576 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1577 /// 1578 /// # Permissions1579 /// 1580 /// * Contract Owner1581 /// 1582 /// # Arguments1583 /// 1584 /// -`contract_address`: Address of the contract to sponsor1585 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1586 /// 1587 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1588 #[transactional]1589 pub fn set_contract_sponsoring_rate_limit(1590 origin,1591 contract_address: T::AccountId,1592 rate_limit: T::BlockNumber1593 ) -> DispatchResult {1594 let sender = ensure_signed(origin)?;15951596 #[cfg(feature = "runtime-benchmarks")]1597 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15981599 Self::ensure_contract_owned(sender, &contract_address)?;1600 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1601 Ok(())1602 }16031604 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1605 /// 1606 /// # Permissions1607 /// 1608 /// * Address that deployed smart contract.1609 /// 1610 /// # Arguments1611 /// 1612 /// -`contract_address`: Address of the contract.1613 /// 1614 /// - `enable`: . 1615 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1616 #[transactional]1617 pub fn toggle_contract_white_list(1618 origin,1619 contract_address: T::AccountId,1620 enable: bool1621 ) -> DispatchResult {1622 let sender = ensure_signed(origin)?;16231624 #[cfg(feature = "runtime-benchmarks")]1625 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16261627 Self::ensure_contract_owned(sender, &contract_address)?;1628 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1629 Ok(())1630 }1631 1632 /// Add an address to smart contract white list.1633 /// 1634 /// # Permissions1635 /// 1636 /// * Address that deployed smart contract.1637 /// 1638 /// # Arguments1639 /// 1640 /// -`contract_address`: Address of the contract.1641 ///1642 /// -`account_address`: Address to add.1643 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1644 #[transactional]1645 pub fn add_to_contract_white_list(1646 origin,1647 contract_address: T::AccountId,1648 account_address: T::AccountId1649 ) -> DispatchResult {1650 let sender = ensure_signed(origin)?;16511652 #[cfg(feature = "runtime-benchmarks")]1653 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1654 1655 Self::ensure_contract_owned(sender, &contract_address)?; 1656 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1657 Ok(())1658 }16591660 /// Remove an address from smart contract white list.1661 /// 1662 /// # Permissions1663 /// 1664 /// * Address that deployed smart contract.1665 /// 1666 /// # Arguments1667 /// 1668 /// -`contract_address`: Address of the contract.1669 ///1670 /// -`account_address`: Address to remove.1671 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1672 #[transactional]1673 pub fn remove_from_contract_white_list(1674 origin,1675 contract_address: T::AccountId,1676 account_address: T::AccountId1677 ) -> DispatchResult {1678 let sender = ensure_signed(origin)?;16791680 #[cfg(feature = "runtime-benchmarks")]1681 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16821683 Self::ensure_contract_owned(sender, &contract_address)?;1684 <ContractWhiteList<T>>::remove(contract_address, account_address);1685 Ok(())1686 }16871688 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1689 #[transactional]1690 pub fn set_collection_limits(1691 origin,1692 collection_id: u32,1693 new_limits: CollectionLimits,1694 ) -> DispatchResult {1695 let sender = ensure_signed(origin)?;1696 Self::check_owner_permissions(collection_id, sender.clone())?;1697 let mut target_collection = <Collection<T>>::get(collection_id);1698 let old_limits = target_collection.limits;1699 let chain_limits = ChainLimit::get();17001701 // collection bounds1702 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1703 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1704 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1705 Error::<T>::CollectionLimitBoundsExceeded);17061707 // token_limit check prev1708 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1709 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17101711 ensure!(1712 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1713 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1714 Error::<T>::OwnerPermissionsCantBeReverted,1715 );17161717 target_collection.limits = new_limits;1718 <Collection<T>>::insert(collection_id, target_collection);17191720 Ok(())1721 } 1722 }1723}17241725impl<T: Config> Module<T> {17261727 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17281729 let target_collection = <Collection<T>>::get(collection_id);17301731 // Limits check1732 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17331734 // Transfer permissions check1735 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1736 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1737 Error::<T>::NoPermission);17381739 if target_collection.access == AccessMode::WhiteList {1740 Self::check_white_list(collection_id, &sender)?;1741 Self::check_white_list(collection_id, &recipient)?;1742 }17431744 match target_collection.mode1745 {1746 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1747 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1748 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1749 _ => ()1750 };17511752 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17531754 Ok(())1755 }175617571758 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17591760 // check token limit and account token limit1761 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1762 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1763 1764 Ok(())1765 }17661767 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17681769 // check token limit and account token limit1770 let total_items: u32 = ItemListIndex::get(collection_id);1771 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1772 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1773 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17741775 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1776 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1777 Self::check_white_list(collection_id, owner)?;1778 Self::check_white_list(collection_id, sender)?;1779 }17801781 Ok(())1782 }17831784 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1785 match target_collection.mode1786 {1787 CollectionMode::NFT => {1788 if let CreateItemData::NFT(data) = data {1789 // check sizes1790 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1791 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1792 } else {1793 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1794 }1795 },1796 CollectionMode::Fungible(_) => {1797 if let CreateItemData::Fungible(_) = data {1798 } else {1799 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1800 }1801 },1802 CollectionMode::ReFungible => {1803 if let CreateItemData::ReFungible(data) = data {18041805 // check sizes1806 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1807 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18081809 // Check refungibility limits1810 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1811 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1812 } else {1813 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1814 }1815 },1816 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1817 };18181819 Ok(())1820 }18211822 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1823 match data1824 {1825 CreateItemData::NFT(data) => {1826 let item = NftItemType {1827 owner: owner.clone(),1828 const_data: data.const_data,1829 variable_data: data.variable_data1830 };18311832 Self::add_nft_item(collection_id, item)?;1833 },1834 CreateItemData::Fungible(data) => {1835 Self::add_fungible_item(collection_id, &owner, data.value)?;1836 },1837 CreateItemData::ReFungible(data) => {1838 let mut owner_list = Vec::new();1839 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18401841 let item = ReFungibleItemType {1842 owner: owner_list,1843 const_data: data.const_data,1844 variable_data: data.variable_data1845 };18461847 Self::add_refungible_item(collection_id, item)?;1848 }1849 };18501851 Ok(())1852 }18531854 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18551856 // Does new owner already have an account?1857 let mut balance: u128 = 0;1858 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1859 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1860 } 18611862 // Mint 1863 let item = FungibleItemType {1864 value: balance + value1865 };1866 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18671868 // Update balance1869 let new_balance = <Balance<T>>::get(collection_id, owner)1870 .checked_add(value)1871 .ok_or(Error::<T>::NumOverflow)?;1872 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18731874 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1875 Ok(())1876 }18771878 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1879 let current_index = <ItemListIndex>::get(collection_id)1880 .checked_add(1)1881 .ok_or(Error::<T>::NumOverflow)?;1882 let itemcopy = item.clone();18831884 ensure!(1885 item.owner.len() == 1,1886 Error::<T>::BadCreateRefungibleCall,1887 );1888 let item_owner = item.owner.first().expect("only one owner is defined");18891890 let value = item_owner.fraction;1891 let owner = item_owner.owner.clone();18921893 Self::add_token_index(collection_id, current_index, &owner)?;18941895 <ItemListIndex>::insert(collection_id, current_index);1896 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18971898 // Update balance1899 let new_balance = <Balance<T>>::get(collection_id, &owner)1900 .checked_add(value)1901 .ok_or(Error::<T>::NumOverflow)?;1902 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19031904 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1905 Ok(())1906 }19071908 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1909 let current_index = <ItemListIndex>::get(collection_id)1910 .checked_add(1)1911 .ok_or(Error::<T>::NumOverflow)?;19121913 let item_owner = item.owner.clone();1914 Self::add_token_index(collection_id, current_index, &item.owner)?;19151916 <ItemListIndex>::insert(collection_id, current_index);1917 <NftItemList<T>>::insert(collection_id, current_index, item);19181919 // Update balance1920 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1921 .checked_add(1)1922 .ok_or(Error::<T>::NumOverflow)?;1923 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19241925 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1926 Ok(())1927 }19281929 fn burn_refungible_item(1930 collection_id: CollectionId,1931 item_id: TokenId,1932 owner: &T::AccountId,1933 ) -> DispatchResult {1934 ensure!(1935 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1936 Error::<T>::TokenNotFound1937 );1938 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1939 let rft_balance = token1940 .owner1941 .iter()1942 .find(|&i| i.owner == *owner)1943 .ok_or(Error::<T>::TokenNotFound)?;1944 Self::remove_token_index(collection_id, item_id, owner)?;19451946 // update balance1947 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1948 .checked_sub(rft_balance.fraction)1949 .ok_or(Error::<T>::NumOverflow)?;1950 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19511952 // Re-create owners list with sender removed1953 let index = token1954 .owner1955 .iter()1956 .position(|i| i.owner == *owner)1957 .expect("owned item is exists");1958 token.owner.remove(index);1959 let owner_count = token.owner.len();19601961 // Burn the token completely if this was the last (only) owner1962 if owner_count == 0 {1963 <ReFungibleItemList<T>>::remove(collection_id, item_id);1964 }1965 else {1966 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1967 }19681969 Ok(())1970 }19711972 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1973 ensure!(1974 <NftItemList<T>>::contains_key(collection_id, item_id),1975 Error::<T>::TokenNotFound1976 );1977 let item = <NftItemList<T>>::get(collection_id, item_id);1978 Self::remove_token_index(collection_id, item_id, &item.owner)?;19791980 // update balance1981 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1982 .checked_sub(1)1983 .ok_or(Error::<T>::NumOverflow)?;1984 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1985 <NftItemList<T>>::remove(collection_id, item_id);19861987 Ok(())1988 }19891990 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1991 ensure!(1992 <FungibleItemList<T>>::contains_key(collection_id, owner),1993 Error::<T>::TokenNotFound1994 );1995 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1996 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19971998 // update balance1999 let new_balance = <Balance<T>>::get(collection_id, owner)2000 .checked_sub(value)2001 .ok_or(Error::<T>::NumOverflow)?;2002 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20032004 if balance.value - value > 0 {2005 balance.value -= value;2006 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2007 }2008 else {2009 <FungibleItemList<T>>::remove(collection_id, owner);2010 }20112012 Ok(())2013 }20142015 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2016 ensure!(2017 <Collection<T>>::contains_key(collection_id),2018 Error::<T>::CollectionNotFound2019 );2020 Ok(())2021 }20222023 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2024 Self::collection_exists(collection_id)?;20252026 let target_collection = <Collection<T>>::get(collection_id);2027 ensure!(2028 subject == target_collection.owner,2029 Error::<T>::NoPermission2030 );20312032 Ok(())2033 }20342035 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2036 let target_collection = <Collection<T>>::get(collection_id);2037 let mut result: bool = subject == target_collection.owner;2038 let exists = <AdminList<T>>::contains_key(collection_id);20392040 if !result & exists {2041 if <AdminList<T>>::get(collection_id).contains(&subject) {2042 result = true2043 }2044 }20452046 result2047 }20482049 fn check_owner_or_admin_permissions(2050 collection_id: CollectionId,2051 subject: T::AccountId,2052 ) -> DispatchResult {2053 Self::collection_exists(collection_id)?;2054 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20552056 ensure!(2057 result,2058 Error::<T>::NoPermission2059 );2060 Ok(())2061 }20622063 fn owned_amount(2064 subject: T::AccountId,2065 collection_id: CollectionId,2066 item_id: TokenId,2067 ) -> Option<u128> {2068 let target_collection = <Collection<T>>::get(collection_id);20692070 match target_collection.mode {2071 CollectionMode::NFT => {2072 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2073 return Some(1)2074 }2075 None2076 },2077 CollectionMode::Fungible(_) => {2078 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2079 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2080 .value);2081 }2082 None2083 },2084 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2085 .owner2086 .iter()2087 .find(|i| i.owner == subject)2088 .map(|i| i.fraction),2089 CollectionMode::Invalid => None,2090 }2091 }20922093 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2094 let target_collection = <Collection<T>>::get(collection_id);20952096 match target_collection.mode {2097 CollectionMode::NFT => {2098 <NftItemList<T>>::get(collection_id, item_id).owner == subject2099 }2100 CollectionMode::Fungible(_) => {2101 <FungibleItemList<T>>::contains_key(collection_id, &subject)2102 }2103 CollectionMode::ReFungible => {2104 <ReFungibleItemList<T>>::get(collection_id, item_id)2105 .owner2106 .iter()2107 .any(|i| i.owner == subject)2108 }2109 CollectionMode::Invalid => false,2110 }2111 }21122113 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2114 let mes = Error::<T>::AddresNotInWhiteList;2115 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21162117 Ok(())2118 }21192120 /// Check if token exists. In case of Fungible, check if there is an entry for 2121 /// the owner in fungible balances double map2122 fn token_exists(2123 collection_id: CollectionId,2124 item_id: TokenId,2125 owner: &T::AccountId2126 ) -> DispatchResult {2127 let target_collection = <Collection<T>>::get(collection_id);2128 let exists = match target_collection.mode2129 {2130 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2131 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2132 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2133 _ => false2134 };21352136 ensure!(exists == true, Error::<T>::TokenNotFound);2137 Ok(())2138 }21392140 fn transfer_fungible(2141 collection_id: CollectionId,2142 value: u128,2143 owner: &T::AccountId,2144 recipient: &T::AccountId,2145 ) -> DispatchResult {2146 Self::token_exists(collection_id, 0, owner)?;21472148 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2149 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21502151 // Send balance to recipient (updates balanceOf of recipient)2152 Self::add_fungible_item(collection_id, recipient, value)?;21532154 // update balanceOf of sender2155 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21562157 // Reduce or remove sender2158 if balance.value == value {2159 <FungibleItemList<T>>::remove(collection_id, owner);2160 }2161 else {2162 balance.value -= value;2163 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2164 }21652166 Ok(())2167 }21682169 fn transfer_refungible(2170 collection_id: CollectionId,2171 item_id: TokenId,2172 value: u128,2173 owner: T::AccountId,2174 new_owner: T::AccountId,2175 ) -> DispatchResult {2176 Self::token_exists(collection_id, item_id, &owner)?;21772178 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2179 let item = full_item2180 .owner2181 .iter()2182 .filter(|i| i.owner == owner)2183 .next()2184 .ok_or(Error::<T>::TokenNotFound)?;2185 let amount = item.fraction;21862187 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21882189 // update balance2190 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2191 .checked_sub(value)2192 .ok_or(Error::<T>::NumOverflow)?;2193 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21942195 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2196 .checked_add(value)2197 .ok_or(Error::<T>::NumOverflow)?;2198 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);21992200 let old_owner = item.owner.clone();2201 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22022203 // transfer2204 if amount == value && !new_owner_has_account {2205 // change owner2206 // new owner do not have account2207 let mut new_full_item = full_item.clone();2208 new_full_item2209 .owner2210 .iter_mut()2211 .find(|i| i.owner == owner)2212 .expect("old owner does present in refungible")2213 .owner = new_owner.clone();2214 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22152216 // update index collection2217 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2218 } else {2219 let mut new_full_item = full_item.clone();2220 new_full_item2221 .owner2222 .iter_mut()2223 .find(|i| i.owner == owner)2224 .expect("old owner does present in refungible")2225 .fraction -= value;22262227 // separate amount2228 if new_owner_has_account {2229 // new owner has account2230 new_full_item2231 .owner2232 .iter_mut()2233 .find(|i| i.owner == new_owner)2234 .expect("new owner has account")2235 .fraction += value;2236 } else {2237 // new owner do not have account2238 new_full_item.owner.push(Ownership {2239 owner: new_owner.clone(),2240 fraction: value,2241 });2242 Self::add_token_index(collection_id, item_id, &new_owner)?;2243 }22442245 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2246 }22472248 Ok(())2249 }22502251 fn transfer_nft(2252 collection_id: CollectionId,2253 item_id: TokenId,2254 sender: T::AccountId,2255 new_owner: T::AccountId,2256 ) -> DispatchResult {2257 Self::token_exists(collection_id, item_id, &sender)?;22582259 let mut item = <NftItemList<T>>::get(collection_id, item_id);22602261 ensure!(2262 sender == item.owner,2263 Error::<T>::MustBeTokenOwner2264 );22652266 // update balance2267 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2268 .checked_sub(1)2269 .ok_or(Error::<T>::NumOverflow)?;2270 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22712272 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2273 .checked_add(1)2274 .ok_or(Error::<T>::NumOverflow)?;2275 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22762277 // change owner2278 let old_owner = item.owner.clone();2279 item.owner = new_owner.clone();2280 <NftItemList<T>>::insert(collection_id, item_id, item);22812282 // update index collection2283 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22842285 Ok(())2286 }2287 2288 fn set_re_fungible_variable_data(2289 collection_id: CollectionId,2290 item_id: TokenId,2291 data: Vec<u8>2292 ) -> DispatchResult {2293 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22942295 item.variable_data = data;22962297 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22982299 Ok(())2300 }23012302 fn set_nft_variable_data(2303 collection_id: CollectionId,2304 item_id: TokenId,2305 data: Vec<u8>2306 ) -> DispatchResult {2307 let mut item = <NftItemList<T>>::get(collection_id, item_id);2308 2309 item.variable_data = data;23102311 <NftItemList<T>>::insert(collection_id, item_id, item);2312 2313 Ok(())2314 }23152316 fn init_collection(item: &CollectionType<T::AccountId>) {2317 // check params2318 assert!(2319 item.decimal_points <= MAX_DECIMAL_POINTS,2320 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2321 );2322 assert!(2323 item.name.len() <= 64,2324 "Collection name can not be longer than 63 char"2325 );2326 assert!(2327 item.name.len() <= 256,2328 "Collection description can not be longer than 255 char"2329 );2330 assert!(2331 item.token_prefix.len() <= 16,2332 "Token prefix can not be longer than 15 char"2333 );23342335 // Generate next collection ID2336 let next_id = CreatedCollectionCount::get()2337 .checked_add(1)2338 .unwrap();23392340 CreatedCollectionCount::put(next_id);2341 }23422343 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2344 let current_index = <ItemListIndex>::get(collection_id)2345 .checked_add(1)2346 .unwrap();23472348 let item_owner = item.owner.clone();2349 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23502351 <ItemListIndex>::insert(collection_id, current_index);23522353 // Update balance2354 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2355 .checked_add(1)2356 .unwrap();2357 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2358 }23592360 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2361 let current_index = <ItemListIndex>::get(collection_id)2362 .checked_add(1)2363 .unwrap();23642365 Self::add_token_index(collection_id, current_index, owner).unwrap();23662367 <ItemListIndex>::insert(collection_id, current_index);23682369 // Update balance2370 let new_balance = <Balance<T>>::get(collection_id, owner)2371 .checked_add(item.value)2372 .unwrap();2373 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2374 }23752376 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2377 let current_index = <ItemListIndex>::get(collection_id)2378 .checked_add(1)2379 .unwrap();23802381 let value = item.owner.first().unwrap().fraction;2382 let owner = item.owner.first().unwrap().owner.clone();23832384 Self::add_token_index(collection_id, current_index, &owner).unwrap();23852386 <ItemListIndex>::insert(collection_id, current_index);23872388 // Update balance2389 let new_balance = <Balance<T>>::get(collection_id, &owner)2390 .checked_add(value)2391 .unwrap();2392 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2393 }23942395 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23962397 // add to account limit2398 if <AccountItemCount<T>>::contains_key(owner) {23992400 // bound Owned tokens by a single address2401 let count = <AccountItemCount<T>>::get(owner);2402 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24032404 <AccountItemCount<T>>::insert(owner.clone(), count2405 .checked_add(1)2406 .ok_or(Error::<T>::NumOverflow)?);2407 }2408 else {2409 <AccountItemCount<T>>::insert(owner.clone(), 1);2410 }24112412 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2413 if list_exists {2414 let mut list = <AddressTokens<T>>::get(collection_id, owner);2415 let item_contains = list.contains(&item_index.clone());24162417 if !item_contains {2418 list.push(item_index.clone());2419 }24202421 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2422 } else {2423 let mut itm = Vec::new();2424 itm.push(item_index.clone());2425 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2426 }24272428 Ok(())2429 }24302431 fn remove_token_index(2432 collection_id: CollectionId,2433 item_index: TokenId,2434 owner: &T::AccountId,2435 ) -> DispatchResult {24362437 // update counter2438 <AccountItemCount<T>>::insert(owner.clone(), 2439 <AccountItemCount<T>>::get(owner)2440 .checked_sub(1)2441 .ok_or(Error::<T>::NumOverflow)?);244224432444 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2445 if list_exists {2446 let mut list = <AddressTokens<T>>::get(collection_id, owner);2447 let item_contains = list.contains(&item_index.clone());24482449 if item_contains {2450 list.retain(|&item| item != item_index);2451 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2452 }2453 }24542455 Ok(())2456 }24572458 fn move_token_index(2459 collection_id: CollectionId,2460 item_index: TokenId,2461 old_owner: &T::AccountId,2462 new_owner: &T::AccountId,2463 ) -> DispatchResult {2464 Self::remove_token_index(collection_id, item_index, old_owner)?;2465 Self::add_token_index(collection_id, item_index, new_owner)?;24662467 Ok(())2468 }2469 2470 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2471 if <ContractOwner<T>>::contains_key(contract.clone()) {2472 let owner = <ContractOwner<T>>::get(contract);2473 ensure!(account == owner, Error::<T>::NoPermission);2474 } else {2475 fail!(Error::<T>::NoPermission);2476 }24772478 Ok(())2479 }2480}24812482////////////////////////////////////////////////////////////////////////////////////////////////////2483// Economic models2484// #region24852486/// Fee multiplier.2487pub type Multiplier = FixedU128;24882489type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;24902491/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2492/// in the queue.2493#[derive(Encode, Decode, Clone, Eq, PartialEq)]2494pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24952496impl<T: Config + Send + Sync> sp_std::fmt::Debug 2497 for ChargeTransactionPayment<T>2498{2499 #[cfg(feature = "std")]2500 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2501 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2502 }2503 #[cfg(not(feature = "std"))]2504 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2505 Ok(())2506 }2507}25082509impl<T: Config> ChargeTransactionPayment<T>2510where2511 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2512 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2513 T::AccountId: AsRef<[u8]>,2514 T::AccountId: UncheckedFrom<T::Hash>,2515{2516 fn traditional_fee(2517 len: usize,2518 info: &DispatchInfoOf<T::Call>,2519 tip: BalanceOf<T>,2520 ) -> BalanceOf<T>2521 where2522 T::Call: Dispatchable<Info = DispatchInfo>,2523 {2524 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2525 }25262527 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2528 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2529 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2530 let len_saturation = max_block_length as u64 / (len as u64).max(1);2531 let coefficient: BalanceOf<T> = weight_saturation2532 .min(len_saturation)2533 .saturated_into::<BalanceOf<T>>();2534 final_fee2535 .saturating_mul(coefficient)2536 .saturated_into::<TransactionPriority>()2537 }25382539 fn withdraw_fee(2540 &self,2541 who: &T::AccountId,2542 call: &T::Call,2543 info: &DispatchInfoOf<T::Call>,2544 len: usize,2545 ) -> Result<2546 (2547 BalanceOf<T>,2548 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2549 ),2550 TransactionValidityError,2551 > {2552 let tip = self.0;25532554 let fee = Self::traditional_fee(len, info, tip);25552556 // Only mess with balances if fee is not zero.2557 if fee.is_zero() {2558 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2559 .map(|i| (fee, i));2560 }25612562 // Determine who is paying transaction fee based on ecnomic model2563 // Parse call to extract collection ID and access collection sponsor2564 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2565 Some(Call::create_item(collection_id, _owner, _properties)) => {25662567 // sponsor timeout2568 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25692570 let collection = <Collection<T>>::get(collection_id);25712572 let limit = collection.limits.sponsor_transfer_timeout;2573 let mut sponsored = true;2574 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2575 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2576 let limit_time = last_tx_block + limit.into();2577 if block_number <= limit_time {2578 sponsored = false;2579 }2580 }2581 if sponsored {2582 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2583 }25842585 // check free create limit2586 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2587 (sponsored)2588 {2589 collection.sponsorship.sponsor()2590 .cloned()2591 .unwrap_or_default()2592 } else {2593 T::AccountId::default()2594 }2595 }2596 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2597 2598 let mut sponsor_transfer = false;2599 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {26002601 let collection_limits = <Collection<T>>::get(collection_id).limits;2602 let collection_mode = <Collection<T>>::get(collection_id).mode;2603 2604 // sponsor timeout2605 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2606 sponsor_transfer = match collection_mode {2607 CollectionMode::NFT => {2608 2609 // get correct limit2610 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2611 collection_limits.sponsor_transfer_timeout2612 } else {2613 ChainLimit::get().nft_sponsor_transfer_timeout2614 };2615 2616 let mut sponsored = true;2617 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2618 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2619 let limit_time = last_tx_block + limit.into();2620 if block_number <= limit_time {2621 sponsored = false;2622 }2623 }2624 if sponsored {2625 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2626 }26272628 sponsored2629 }2630 CollectionMode::Fungible(_) => {2631 2632 // get correct limit2633 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2634 collection_limits.sponsor_transfer_timeout2635 } else {2636 ChainLimit::get().fungible_sponsor_transfer_timeout2637 };2638 2639 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2640 let mut sponsored = true;2641 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2642 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2643 let limit_time = last_tx_block + limit.into();2644 if block_number <= limit_time {2645 sponsored = false;2646 }2647 }2648 if sponsored {2649 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2650 }26512652 sponsored2653 }2654 CollectionMode::ReFungible => {2655 2656 // get correct limit2657 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2658 collection_limits.sponsor_transfer_timeout2659 } else {2660 ChainLimit::get().refungible_sponsor_transfer_timeout2661 };2662 2663 let mut sponsored = true;2664 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2665 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2666 let limit_time = last_tx_block + limit.into();2667 if block_number <= limit_time {2668 sponsored = false;2669 }2670 }2671 if sponsored {2672 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2673 }26742675 sponsored2676 }2677 _ => {2678 false2679 },2680 };2681 }26822683 if !sponsor_transfer {2684 T::AccountId::default()2685 } else {2686 <Collection<T>>::get(collection_id).sponsorship.sponsor()2687 .cloned()2688 .unwrap_or_default()2689 }2690 }26912692 _ => T::AccountId::default(),2693 };26942695 // Sponsor smart contracts2696 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26972698 // On instantiation: set the contract owner2699 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27002701 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2702 &who,2703 code_hash,2704 salt,2705 );2706 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27072708 T::AccountId::default()2709 },27102711 // On instantiation with code: set the contract owner2712 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27132714 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2715 &who,2716 &T::Hashing::hash(&_code),2717 _salt,2718 );27192720 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27212722 T::AccountId::default()2723 }27242725 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2726 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27272728 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27292730 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2731 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2732 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2733 2734 if !owned_contract && white_list_enabled {2735 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2736 return Err(InvalidTransaction::Call.into());2737 }2738 }27392740 let mut sponsor_transfer = false;2741 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2742 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2743 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2744 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2745 let limit_time = last_tx_block + rate_limit;27462747 if block_number >= limit_time {2748 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2749 sponsor_transfer = true;2750 }2751 } else {2752 sponsor_transfer = false;2753 }2754 2755 2756 let mut sp = T::AccountId::default();2757 if sponsor_transfer {2758 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2759 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2760 sp = called_contract;2761 }2762 }2763 }27642765 sp2766 },27672768 _ => sponsor,2769 };27702771 let mut who_pays_fee: T::AccountId = sponsor.clone();2772 if sponsor == T::AccountId::default() {2773 who_pays_fee = who.clone();2774 }27752776 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2777 .map(|i| (fee, i))2778 }2779}278027812782impl<T: Config + Send + Sync> SignedExtension2783 for ChargeTransactionPayment<T>2784where2785 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2786 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2787 T::AccountId: AsRef<[u8]>,2788 T::AccountId: UncheckedFrom<T::Hash>,2789{2790 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2791 type AccountId = T::AccountId;2792 type Call = T::Call;2793 type AdditionalSigned = ();2794 type Pre = (2795 // tip2796 BalanceOf<T>,2797 // who pays fee2798 Self::AccountId,2799 // imbalance resulting from withdrawing the fee2800 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2801 );2802 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2803 Ok(())2804 }28052806 fn validate(2807 &self,2808 who: &Self::AccountId,2809 call: &Self::Call,2810 info: &DispatchInfoOf<Self::Call>,2811 len: usize,2812 ) -> TransactionValidity {2813 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2814 Ok(ValidTransaction {2815 priority: Self::get_priority(len, info, fee),2816 ..Default::default()2817 })2818 }28192820 fn pre_dispatch(2821 self,2822 who: &Self::AccountId,2823 call: &Self::Call,2824 info: &DispatchInfoOf<Self::Call>,2825 len: usize,2826 ) -> Result<Self::Pre, TransactionValidityError> {2827 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2828 Ok((self.0, who.clone(), imbalance))2829 }28302831 fn post_dispatch(2832 pre: Self::Pre,2833 info: &DispatchInfoOf<Self::Call>,2834 post_info: &PostDispatchInfoOf<Self::Call>,2835 len: usize,2836 _result: &DispatchResult,2837 ) -> Result<(), TransactionValidityError> {2838 let (tip, who, imbalance) = pre;2839 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2840 len as u32,2841 info,2842 post_info,2843 tip,2844 );2845 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2846 Ok(())2847 }2848}28492850// #endregion1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![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 codec::{Decode, Encode};17pub use frame_support::{18 construct_runtime, decl_event, decl_module, decl_storage, decl_error,19 dispatch::DispatchResult,20 ensure, fail, parameter_types,21 traits::{22 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,23 Randomness, IsSubType, WithdrawReasons,24 },25 weights::{26 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},27 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,28 WeightToFeePolynomial, DispatchClass,29 },30 StorageValue,31 transactional,32};3334use frame_system::{self as system, ensure_signed, ensure_root};35use sp_runtime::sp_std::prelude::Vec;36use sp_runtime::{37 traits::{38 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,39 },40 transaction_validity::{41 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,42 },43 FixedPointOperand, FixedU128,44};45use sp_runtime::traits::StaticLookup;46use pallet_contracts::chain_extension::UncheckedFrom;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;5657pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;58pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;59pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;60pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6162// Structs63// #region6465pub type CollectionId = u32;66pub type TokenId = u32;67pub type DecimalPoints = u8;6869#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]70#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]71pub enum CollectionMode {72 Invalid,73 NFT,74 // decimal points75 Fungible(DecimalPoints),76 ReFungible,77}7879impl Default for CollectionMode {80 fn default() -> Self {81 Self::Invalid82 }83}8485impl Into<u8> for CollectionMode {86 fn into(self) -> u8 {87 match self {88 CollectionMode::Invalid => 0,89 CollectionMode::NFT => 1,90 CollectionMode::Fungible(_) => 2,91 CollectionMode::ReFungible => 3,92 }93 }94}9596#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]97#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]98pub enum AccessMode {99 Normal,100 WhiteList,101}102impl Default for AccessMode {103 fn default() -> Self {104 Self::Normal105 }106}107108#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]109#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]110pub enum SchemaVersion {111 ImageURL,112 Unique,113}114impl Default for SchemaVersion {115 fn default() -> Self {116 Self::ImageURL117 }118}119120#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]121#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]122pub struct Ownership<AccountId> {123 pub owner: AccountId,124 pub fraction: u128,125}126127#[derive(Encode, Decode, Debug, Clone, PartialEq)]128#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]129pub enum SponsorshipState<AccountId> {130 /// The fees are applied to the transaction sender131 Disabled,132 Unconfirmed(AccountId),133 /// Transactions are sponsored by specified account134 Confirmed(AccountId),135}136137impl<AccountId> SponsorshipState<AccountId> {138 fn sponsor(&self) -> Option<&AccountId> {139 match self {140 Self::Confirmed(sponsor) => Some(sponsor),141 _ => None,142 }143 }144145 fn pending_sponsor(&self) -> Option<&AccountId> {146 match self {147 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),148 _ => None,149 }150 }151152 fn confirmed(&self) -> bool {153 matches!(self, Self::Confirmed(_))154 }155}156157impl<T> Default for SponsorshipState<T> {158 fn default() -> Self {159 Self::Disabled160 }161}162163#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]164#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]165pub struct CollectionType<AccountId> {166 pub owner: AccountId,167 pub mode: CollectionMode,168 pub access: AccessMode,169 pub decimal_points: DecimalPoints,170 pub name: Vec<u16>, // 64 include null escape char171 pub description: Vec<u16>, // 256 include null escape char172 pub token_prefix: Vec<u8>, // 16 include null escape char173 pub mint_mode: bool,174 pub offchain_schema: Vec<u8>,175 pub schema_version: SchemaVersion,176 pub sponsorship: SponsorshipState<AccountId>,177 pub limits: CollectionLimits, // Collection private restrictions 178 pub variable_on_chain_schema: Vec<u8>, //179 pub const_on_chain_schema: Vec<u8>, //180}181182#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]183#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]184pub struct NftItemType<AccountId> {185 pub owner: AccountId,186 pub const_data: Vec<u8>,187 pub variable_data: Vec<u8>,188}189190#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]191#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]192pub struct FungibleItemType {193 pub value: u128,194}195196#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]197#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]198pub struct ReFungibleItemType<AccountId> {199 pub owner: Vec<Ownership<AccountId>>,200 pub const_data: Vec<u8>,201 pub variable_data: Vec<u8>,202}203204// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]205// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206// pub struct VestingItem<AccountId, Moment> {207// pub sender: AccountId,208// pub recipient: AccountId,209// pub collection_id: CollectionId,210// pub item_id: TokenId,211// pub amount: u64,212// pub vesting_date: Moment,213// }214215#[derive(Encode, Decode, Debug, Clone, PartialEq)]216#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]217pub struct CollectionLimits {218 pub account_token_ownership_limit: u32,219 pub sponsored_data_size: u32,220 pub token_limit: u32,221222 // Timeouts for item types in passed blocks223 pub sponsor_transfer_timeout: u32,224 pub owner_can_transfer: bool,225 pub owner_can_destroy: bool,226}227228impl Default for CollectionLimits {229 fn default() -> CollectionLimits {230 CollectionLimits { 231 account_token_ownership_limit: 10_000_000, 232 token_limit: u32::max_value(),233 sponsored_data_size: u32::MAX,234 sponsor_transfer_timeout: 14400,235 owner_can_transfer: true,236 owner_can_destroy: true237 }238 }239}240241#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]242#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]243pub struct ChainLimits {244 pub collection_numbers_limit: u32,245 pub account_token_ownership_limit: u32,246 pub collections_admins_limit: u64,247 pub custom_data_limit: u32,248249 // Timeouts for item types in passed blocks250 pub nft_sponsor_transfer_timeout: u32,251 pub fungible_sponsor_transfer_timeout: u32,252 pub refungible_sponsor_transfer_timeout: u32,253254 // Schema limits255 pub offchain_schema_limit: u32,256 pub variable_on_chain_schema_limit: u32,257 pub const_on_chain_schema_limit: u32,258}259260pub trait WeightInfo {261 fn create_collection() -> Weight;262 fn destroy_collection() -> Weight;263 fn add_to_white_list() -> Weight;264 fn remove_from_white_list() -> Weight;265 fn set_public_access_mode() -> Weight;266 fn set_mint_permission() -> Weight;267 fn change_collection_owner() -> Weight;268 fn add_collection_admin() -> Weight;269 fn remove_collection_admin() -> Weight;270 fn set_collection_sponsor() -> Weight;271 fn confirm_sponsorship() -> Weight;272 fn remove_collection_sponsor() -> Weight;273 fn create_item(s: usize) -> Weight;274 fn burn_item() -> Weight;275 fn transfer() -> Weight;276 fn approve() -> Weight;277 fn transfer_from() -> Weight;278 fn set_offchain_schema() -> Weight;279 fn set_const_on_chain_schema() -> Weight;280 fn set_variable_on_chain_schema() -> Weight;281 fn set_variable_meta_data() -> Weight;282 fn enable_contract_sponsoring() -> Weight;283 fn set_schema_version() -> Weight;284 fn set_chain_limits() -> Weight;285 fn set_contract_sponsoring_rate_limit() -> Weight;286 fn toggle_contract_white_list() -> Weight;287 fn add_to_contract_white_list() -> Weight;288 fn remove_from_contract_white_list() -> Weight;289 fn set_collection_limits() -> Weight;290}291292#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]293#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]294pub struct CreateNftData {295 pub const_data: Vec<u8>,296 pub variable_data: Vec<u8>,297}298299#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]300#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]301pub struct CreateFungibleData {302 pub value: u128,303}304305#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]306#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]307pub struct CreateReFungibleData {308 pub const_data: Vec<u8>,309 pub variable_data: Vec<u8>,310 pub pieces: u128,311}312313#[derive(Encode, Decode, Debug, Clone, PartialEq)]314#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]315pub enum CreateItemData {316 NFT(CreateNftData),317 Fungible(CreateFungibleData),318 ReFungible(CreateReFungibleData),319}320321impl CreateItemData {322 pub fn len(&self) -> usize {323 let len = match self {324 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),325 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),326 _ => 0327 };328 329 return len;330 }331}332333impl From<CreateNftData> for CreateItemData {334 fn from(item: CreateNftData) -> Self {335 CreateItemData::NFT(item)336 }337}338339impl From<CreateReFungibleData> for CreateItemData {340 fn from(item: CreateReFungibleData) -> Self {341 CreateItemData::ReFungible(item)342 }343}344345impl From<CreateFungibleData> for CreateItemData {346 fn from(item: CreateFungibleData) -> Self {347 CreateItemData::Fungible(item)348 }349}350351352decl_error! {353 /// Error for non-fungible-token module.354 pub enum Error for Module<T: Config> {355 /// Total collections bound exceeded.356 TotalCollectionsLimitExceeded,357 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.358 CollectionDecimalPointLimitExceeded, 359 /// Collection name can not be longer than 63 char.360 CollectionNameLimitExceeded, 361 /// Collection description can not be longer than 255 char.362 CollectionDescriptionLimitExceeded, 363 /// Token prefix can not be longer than 15 char.364 CollectionTokenPrefixLimitExceeded,365 /// This collection does not exist.366 CollectionNotFound,367 /// Item not exists.368 TokenNotFound,369 /// Admin not found370 AdminNotFound,371 /// Arithmetic calculation overflow.372 NumOverflow, 373 /// Account already has admin role.374 AlreadyAdmin, 375 /// You do not own this collection.376 NoPermission,377 /// This address is not set as sponsor, use setCollectionSponsor first.378 ConfirmUnsetSponsorFail,379 /// Collection is not in mint mode.380 PublicMintingNotAllowed,381 /// Sender parameter and item owner must be equal.382 MustBeTokenOwner,383 /// Item balance not enough.384 TokenValueTooLow,385 /// Size of item is too large.386 NftSizeLimitExceeded,387 /// No approve found388 ApproveNotFound,389 /// Requested value more than approved.390 TokenValueNotEnough,391 /// Only approved addresses can call this method.392 ApproveRequired,393 /// Address is not in white list.394 AddresNotInWhiteList,395 /// Number of collection admins bound exceeded.396 CollectionAdminsLimitExceeded,397 /// Owned tokens by a single address bound exceeded.398 AddressOwnershipLimitExceeded,399 /// Length of items properties must be greater than 0.400 EmptyArgument,401 /// const_data exceeded data limit.402 TokenConstDataLimitExceeded,403 /// variable_data exceeded data limit.404 TokenVariableDataLimitExceeded,405 /// Not NFT item data used to mint in NFT collection.406 NotNftDataUsedToMintNftCollectionToken,407 /// Not Fungible item data used to mint in Fungible collection.408 NotFungibleDataUsedToMintFungibleCollectionToken,409 /// Not Re Fungible item data used to mint in Re Fungible collection.410 NotReFungibleDataUsedToMintReFungibleCollectionToken,411 /// Unexpected collection type.412 UnexpectedCollectionType,413 /// Can't store metadata in fungible tokens.414 CantStoreMetadataInFungibleTokens,415 /// Collection token limit exceeded416 CollectionTokenLimitExceeded,417 /// Account token limit exceeded per collection418 AccountTokenLimitExceeded,419 /// Collection limit bounds per collection exceeded420 CollectionLimitBoundsExceeded,421 /// Tried to enable permissions which are only permitted to be disabled422 OwnerPermissionsCantBeReverted,423 /// Schema data size limit bound exceeded424 SchemaDataLimitExceeded,425 /// Maximum refungibility exceeded426 WrongRefungiblePieces,427 /// createRefungible should be called with one owner428 BadCreateRefungibleCall,429 }430}431432pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {433 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;434435 /// Weight information for extrinsics in this pallet.436 type WeightInfo: WeightInfo;437438 type Currency: Currency<Self::AccountId>;439 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;440 type TreasuryAccountId: Get<Self::AccountId>;441}442443#[cfg(feature = "runtime-benchmarks")]444mod benchmarking;445446// #endregion447448// # Used definitions449//450// ## User control levels451//452// chain-controlled - key is uncontrolled by user453// i.e autoincrementing index454// can use non-cryptographic hash455// real - key is controlled by user456// but it is hard to generate enough colliding values, i.e owner of signed txs457// can use non-cryptographic hash458// controlled - key is completly controlled by users459// i.e maps with mutable keys460// should use cryptographic hash461//462// ## User control level downgrade reasons463//464// ?1 - chain-controlled -> controlled465// collections/tokens can be destroyed, resulting in massive holes466// ?2 - chain-controlled -> controlled467// same as ?1, but can be only added, resulting in easier exploitation468// ?3 - real -> controlled469// no confirmation required, so addresses can be easily generated470decl_storage! {471 trait Store for Module<T: Config> as Nft {472473 //#region Private members474 /// Id of next collection475 CreatedCollectionCount: u32;476 /// Used for migrations477 ChainVersion: u64;478 /// Id of last collection token479 /// Collection id (controlled?1)480 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;481 //#endregion482483 //#region Chain limits struct484 pub ChainLimit get(fn chain_limit) config(): ChainLimits;485 //#endregion486487 //#region Bound counters488 /// Amount of collections destroyed, used for total amount tracking with489 /// CreatedCollectionCount490 DestroyedCollectionCount: u32;491 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)492 /// Account id (real)493 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;494 //#endregion495496 //#region Basic collections497 /// Collection info498 /// Collection id (controlled?1)499 pub Collection get(fn collection) config(): map hasher(blake2_128_concat) CollectionId => CollectionType<T::AccountId>;500 /// List of collection admins501 /// Collection id (controlled?2)502 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;503 /// Whitelisted collection users504 /// Collection id (controlled?2), user id (controlled?3)505 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;506 //#endregion507508 /// How many of collection items user have509 /// Collection id (controlled?2), account id (real)510 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;511512 /// Amount of items which spender can transfer out of owners account (via transferFrom)513 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))514 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;515516 //#region Item collections517 /// Collection id (controlled?2), token id (controlled?1)518 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;519 /// Collection id (controlled?2), owner (controlled?2)520 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;521 /// Collection id (controlled?2), token id (controlled?1)522 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;523 //#endregion524525 //#region Index list526 /// Collection id (controlled?2), tokens owner (controlled?2)527 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;528 //#endregion529530 //#region Tokens transfer rate limit baskets531 /// (Collection id (controlled?2), who created (real))532 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;533 /// Collection id (controlled?2), token id (controlled?2)534 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;535 /// Collection id (controlled?2), owning user (real)536 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;537 /// Collection id (controlled?2), token id (controlled?2)538 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;539 //#endregion540541 //#region Contract Sponsorship and Ownership542 /// Contract address (real)543 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;544 /// Contract address (real)545 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;546 /// (Contract address(real), caller (real))547 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;548 /// Contract address (real)549 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;550 /// Contract address (real)551 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 552 /// Contract address (real) => Whitelisted user (controlled?3)553 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 554 //#endregion555 }556 add_extra_genesis {557 build(|config: &GenesisConfig<T>| {558 // Modification of storage559 for (_num, _c) in &config.collection {560 <Module<T>>::init_collection(_c);561 }562563 for (_num, _c, _i) in &config.nft_item_id {564 <Module<T>>::init_nft_token(*_c, _i);565 }566567 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {568 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);569 }570571 for (_num, _c, _i) in &config.refungible_item_id {572 <Module<T>>::init_refungible_token(*_c, _i);573 }574 })575 }576}577578decl_event!(579 pub enum Event<T>580 where581 AccountId = <T as system::Config>::AccountId,582 {583 /// New collection was created584 /// 585 /// # Arguments586 /// 587 /// * collection_id: Globally unique identifier of newly created collection.588 /// 589 /// * mode: [CollectionMode] converted into u8.590 /// 591 /// * account_id: Collection owner.592 Created(CollectionId, u8, AccountId),593594 /// New item was created.595 /// 596 /// # Arguments597 /// 598 /// * collection_id: Id of the collection where item was created.599 /// 600 /// * item_id: Id of an item. Unique within the collection.601 ///602 /// * recipient: Owner of newly created item 603 ItemCreated(CollectionId, TokenId, AccountId),604605 /// Collection item was burned.606 /// 607 /// # Arguments608 /// 609 /// collection_id.610 /// 611 /// item_id: Identifier of burned NFT.612 ItemDestroyed(CollectionId, TokenId),613614 /// Item was transferred615 ///616 /// * collection_id: Id of collection to which item is belong617 ///618 /// * item_id: Id of an item619 ///620 /// * sender: Original owner of item621 ///622 /// * recipient: New owner of item623 ///624 /// * amount: Always 1 for NFT625 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),626 }627);628629decl_module! {630 pub struct Module<T: Config> for enum Call 631 where 632 origin: T::Origin633 {634 fn deposit_event() = default;635 type Error = Error<T>;636637 fn on_initialize(now: T::BlockNumber) -> Weight {638 0639 }640641 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.642 /// 643 /// # Permissions644 /// 645 /// * Anyone.646 /// 647 /// # Arguments648 /// 649 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.650 /// 651 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.652 /// 653 /// * token_prefix: UTF-8 string with token prefix.654 /// 655 /// * mode: [CollectionMode] collection type and type dependent data.656 // returns collection ID657 #[weight = <T as Config>::WeightInfo::create_collection()]658 #[transactional]659 pub fn create_collection(origin,660 collection_name: Vec<u16>,661 collection_description: Vec<u16>,662 token_prefix: Vec<u8>,663 mode: CollectionMode) -> DispatchResult {664665 // Anyone can create a collection666 let who = ensure_signed(origin)?;667668 // Take a (non-refundable) deposit of collection creation669 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();670 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(671 &T::TreasuryAccountId::get(),672 T::CollectionCreationPrice::get(),673 ));674 <T as Config>::Currency::settle(675 &who,676 imbalance,677 WithdrawReasons::TRANSFER,678 ExistenceRequirement::KeepAlive,679 ).map_err(|_| Error::<T>::NoPermission)?;680681 let decimal_points = match mode {682 CollectionMode::Fungible(points) => points,683 _ => 0684 };685686 let chain_limit = ChainLimit::get();687688 let created_count = CreatedCollectionCount::get();689 let destroyed_count = DestroyedCollectionCount::get();690691 // bound Total number of collections692 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);693694 // check params695 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);696 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);697 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);698 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);699700 // Generate next collection ID701 let next_id = created_count702 .checked_add(1)703 .ok_or(Error::<T>::NumOverflow)?;704705 CreatedCollectionCount::put(next_id);706707 let limits = CollectionLimits {708 sponsored_data_size: chain_limit.custom_data_limit,709 ..Default::default()710 };711712 // Create new collection713 let new_collection = CollectionType {714 owner: who.clone(),715 name: collection_name,716 mode: mode.clone(),717 mint_mode: false,718 access: AccessMode::Normal,719 description: collection_description,720 decimal_points: decimal_points,721 token_prefix: token_prefix,722 offchain_schema: Vec::new(),723 schema_version: SchemaVersion::ImageURL,724 sponsorship: SponsorshipState::Disabled,725 variable_on_chain_schema: Vec::new(),726 const_on_chain_schema: Vec::new(),727 limits,728 };729730 // Add new collection to map731 <Collection<T>>::insert(next_id, new_collection);732733 // call event734 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));735736 Ok(())737 }738739 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.740 /// 741 /// # Permissions742 /// 743 /// * Collection Owner.744 /// 745 /// # Arguments746 /// 747 /// * collection_id: collection to destroy.748 #[weight = <T as Config>::WeightInfo::destroy_collection()]749 #[transactional]750 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {751752 let sender = ensure_signed(origin)?;753 Self::check_owner_permissions(collection_id, sender)?;754755 let target_collection = <Collection<T>>::get(collection_id);756 if !target_collection.limits.owner_can_destroy {757 fail!(Error::<T>::NoPermission);758 }759760 <AddressTokens<T>>::remove_prefix(collection_id);761 <Allowances<T>>::remove_prefix(collection_id);762 <Balance<T>>::remove_prefix(collection_id);763 <ItemListIndex>::remove(collection_id);764 <AdminList<T>>::remove(collection_id);765 <Collection<T>>::remove(collection_id);766 <WhiteList<T>>::remove_prefix(collection_id);767768 <NftItemList<T>>::remove_prefix(collection_id);769 <FungibleItemList<T>>::remove_prefix(collection_id);770 <ReFungibleItemList<T>>::remove_prefix(collection_id);771772 <NftTransferBasket<T>>::remove_prefix(collection_id);773 <FungibleTransferBasket<T>>::remove_prefix(collection_id);774 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);775776 DestroyedCollectionCount::put(DestroyedCollectionCount::get()777 .checked_add(1)778 .ok_or(Error::<T>::NumOverflow)?);779780 Ok(())781 }782783 /// Add an address to white list.784 /// 785 /// # Permissions786 /// 787 /// * Collection Owner788 /// * Collection Admin789 /// 790 /// # Arguments791 /// 792 /// * collection_id.793 /// 794 /// * address.795 #[weight = <T as Config>::WeightInfo::add_to_white_list()]796 #[transactional]797 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{798799 let sender = ensure_signed(origin)?;800 Self::check_owner_or_admin_permissions(collection_id, sender)?;801802 <WhiteList<T>>::insert(collection_id, address, true);803 804 Ok(())805 }806807 /// Remove an address from white list.808 /// 809 /// # Permissions810 /// 811 /// * Collection Owner812 /// * Collection Admin813 /// 814 /// # Arguments815 /// 816 /// * collection_id.817 /// 818 /// * address.819 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]820 #[transactional]821 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{822823 let sender = ensure_signed(origin)?;824 Self::check_owner_or_admin_permissions(collection_id, sender)?;825826 <WhiteList<T>>::remove(collection_id, address);827828 Ok(())829 }830831 /// Toggle between normal and white list access for the methods with access for `Anyone`.832 /// 833 /// # Permissions834 /// 835 /// * Collection Owner.836 /// 837 /// # Arguments838 /// 839 /// * collection_id.840 /// 841 /// * mode: [AccessMode]842 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]843 #[transactional]844 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult845 {846 let sender = ensure_signed(origin)?;847848 Self::check_owner_permissions(collection_id, sender)?;849 let mut target_collection = <Collection<T>>::get(collection_id);850 target_collection.access = mode;851 <Collection<T>>::insert(collection_id, target_collection);852853 Ok(())854 }855856 /// Allows Anyone to create tokens if:857 /// * White List is enabled, and858 /// * Address is added to white list, and859 /// * This method was called with True parameter860 /// 861 /// # Permissions862 /// * Collection Owner863 ///864 /// # Arguments865 /// 866 /// * collection_id.867 /// 868 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.869 #[weight = <T as Config>::WeightInfo::set_mint_permission()]870 #[transactional]871 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult872 {873 let sender = ensure_signed(origin)?;874875 Self::check_owner_permissions(collection_id, sender)?;876 let mut target_collection = <Collection<T>>::get(collection_id);877 target_collection.mint_mode = mint_permission;878 <Collection<T>>::insert(collection_id, target_collection);879880 Ok(())881 }882883 /// Change the owner of the collection.884 /// 885 /// # Permissions886 /// 887 /// * Collection Owner.888 /// 889 /// # Arguments890 /// 891 /// * collection_id.892 /// 893 /// * new_owner.894 #[weight = <T as Config>::WeightInfo::change_collection_owner()]895 #[transactional]896 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {897898 let sender = ensure_signed(origin)?;899 Self::check_owner_permissions(collection_id, sender)?;900 let mut target_collection = <Collection<T>>::get(collection_id);901 target_collection.owner = new_owner;902 <Collection<T>>::insert(collection_id, target_collection);903904 Ok(())905 }906907 /// Adds an admin of the Collection.908 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 909 /// 910 /// # Permissions911 /// 912 /// * Collection Owner.913 /// * Collection Admin.914 /// 915 /// # Arguments916 /// 917 /// * collection_id: ID of the Collection to add admin for.918 /// 919 /// * new_admin_id: Address of new admin to add.920 #[weight = <T as Config>::WeightInfo::add_collection_admin()]921 #[transactional]922 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {923924 let sender = ensure_signed(origin)?;925 Self::check_owner_or_admin_permissions(collection_id, sender)?;926 let mut admin_arr: Vec<T::AccountId> = Vec::new();927928 if <AdminList<T>>::contains_key(collection_id)929 {930 admin_arr = <AdminList<T>>::get(collection_id);931 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);932 }933934 // Number of collection admins935 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);936937 admin_arr.push(new_admin_id);938 <AdminList<T>>::insert(collection_id, admin_arr);939940 Ok(())941 }942943 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.944 ///945 /// # Permissions946 /// 947 /// * Collection Owner.948 /// * Collection Admin.949 /// 950 /// # Arguments951 /// 952 /// * collection_id: ID of the Collection to remove admin for.953 /// 954 /// * account_id: Address of admin to remove.955 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]956 #[transactional]957 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {958959 let sender = ensure_signed(origin)?;960 Self::check_owner_or_admin_permissions(collection_id, sender)?;961 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);962963 let mut admin_arr = <AdminList<T>>::get(collection_id);964 admin_arr.retain(|i| *i != account_id);965 <AdminList<T>>::insert(collection_id, admin_arr);966967 Ok(())968 }969970 /// # Permissions971 /// 972 /// * Collection Owner973 /// 974 /// # Arguments975 /// 976 /// * collection_id.977 /// 978 /// * new_sponsor.979 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]980 #[transactional]981 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {982983 let sender = ensure_signed(origin)?;984 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);985986 let mut target_collection = <Collection<T>>::get(collection_id);987 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);988989 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);990 <Collection<T>>::insert(collection_id, target_collection);991992 Ok(())993 }994995 /// # Permissions996 /// 997 /// * Sponsor.998 /// 999 /// # Arguments1000 /// 1001 /// * collection_id.1002 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1003 #[transactional]1004 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10051006 let sender = ensure_signed(origin)?;1007 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10081009 let mut target_collection = <Collection<T>>::get(collection_id);1010 ensure!(1011 target_collection.sponsorship.pending_sponsor() == Some(&sender),1012 Error::<T>::ConfirmUnsetSponsorFail1013 );10141015 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1016 <Collection<T>>::insert(collection_id, target_collection);10171018 Ok(())1019 }10201021 /// Switch back to pay-per-own-transaction model.1022 ///1023 /// # Permissions1024 ///1025 /// * Collection owner.1026 /// 1027 /// # Arguments1028 /// 1029 /// * collection_id.1030 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1031 #[transactional]1032 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10331034 let sender = ensure_signed(origin)?;1035 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10361037 let mut target_collection = <Collection<T>>::get(collection_id);1038 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10391040 target_collection.sponsorship = SponsorshipState::Disabled;1041 <Collection<T>>::insert(collection_id, target_collection);10421043 Ok(())1044 }10451046 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1047 /// 1048 /// # Permissions1049 /// 1050 /// * Collection Owner.1051 /// * Collection Admin.1052 /// * Anyone if1053 /// * White List is enabled, and1054 /// * Address is added to white list, and1055 /// * MintPermission is enabled (see SetMintPermission method)1056 /// 1057 /// # Arguments1058 /// 1059 /// * collection_id: ID of the collection.1060 /// 1061 /// * owner: Address, initial owner of the NFT.1062 ///1063 /// * data: Token data to store on chain.1064 // #[weight =1065 // (130_000_000 as Weight)1066 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1067 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1068 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]10691070 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1071 #[transactional]1072 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10731074 let sender = ensure_signed(origin)?;10751076 Self::collection_exists(collection_id)?;10771078 let target_collection = <Collection<T>>::get(collection_id);10791080 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1081 Self::validate_create_item_args(&target_collection, &data)?;1082 Self::create_item_no_validation(collection_id, owner, data)?;10831084 Ok(())1085 }10861087 /// This method creates multiple items in a collection created with CreateCollection method.1088 /// 1089 /// # Permissions1090 /// 1091 /// * Collection Owner.1092 /// * Collection Admin.1093 /// * Anyone if1094 /// * White List is enabled, and1095 /// * Address is added to white list, and1096 /// * MintPermission is enabled (see SetMintPermission method)1097 /// 1098 /// # Arguments1099 /// 1100 /// * collection_id: ID of the collection.1101 /// 1102 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1103 /// 1104 /// * owner: Address, initial owner of the NFT.1105 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1106 .map(|data| { data.len() })1107 .sum())]1108 #[transactional]1109 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11101111 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1112 let sender = ensure_signed(origin)?;11131114 Self::collection_exists(collection_id)?;1115 let target_collection = <Collection<T>>::get(collection_id);11161117 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11181119 for data in &items_data {1120 Self::validate_create_item_args(&target_collection, data)?;1121 }1122 for data in &items_data {1123 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1124 }11251126 Ok(())1127 }11281129 /// Destroys a concrete instance of NFT.1130 /// 1131 /// # Permissions1132 /// 1133 /// * Collection Owner.1134 /// * Collection Admin.1135 /// * Current NFT Owner.1136 /// 1137 /// # Arguments1138 /// 1139 /// * collection_id: ID of the collection.1140 /// 1141 /// * item_id: ID of NFT to burn.1142 #[weight = <T as Config>::WeightInfo::burn_item()]1143 #[transactional]1144 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11451146 let sender = ensure_signed(origin)?;1147 Self::collection_exists(collection_id)?;11481149 // Transfer permissions check1150 let target_collection = <Collection<T>>::get(collection_id);1151 ensure!(1152 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1153 (1154 target_collection.limits.owner_can_transfer &&1155 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1156 ),1157 Error::<T>::NoPermission1158 );11591160 if target_collection.access == AccessMode::WhiteList {1161 Self::check_white_list(collection_id, &sender)?;1162 }11631164 match target_collection.mode1165 {1166 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1167 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1168 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1169 _ => ()1170 };11711172 // call event1173 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11741175 Ok(())1176 }11771178 /// Change ownership of the token.1179 /// 1180 /// # Permissions1181 /// 1182 /// * Collection Owner1183 /// * Collection Admin1184 /// * Current NFT owner1185 ///1186 /// # Arguments1187 /// 1188 /// * recipient: Address of token recipient.1189 /// 1190 /// * collection_id.1191 /// 1192 /// * item_id: ID of the item1193 /// * Non-Fungible Mode: Required.1194 /// * Fungible Mode: Ignored.1195 /// * Re-Fungible Mode: Required.1196 /// 1197 /// * value: Amount to transfer.1198 /// * Non-Fungible Mode: Ignored1199 /// * Fungible Mode: Must specify transferred amount1200 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1201 #[weight = <T as Config>::WeightInfo::transfer()]1202 #[transactional]1203 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1204 let sender = ensure_signed(origin)?;1205 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1206 }12071208 /// Set, change, or remove approved address to transfer the ownership of the NFT.1209 /// 1210 /// # Permissions1211 /// 1212 /// * Collection Owner1213 /// * Collection Admin1214 /// * Current NFT owner1215 /// 1216 /// # Arguments1217 /// 1218 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1219 /// 1220 /// * collection_id.1221 /// 1222 /// * item_id: ID of the item.1223 #[weight = <T as Config>::WeightInfo::approve()]1224 #[transactional]1225 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12261227 let sender = ensure_signed(origin)?;12281229 Self::collection_exists(collection_id)?;1230 Self::token_exists(collection_id, item_id, &sender)?;12311232 // Transfer permissions check1233 let target_collection = <Collection<T>>::get(collection_id);1234 let allowance_limit = if target_collection.limits.owner_can_transfer &&1235 Self::is_owner_or_admin_permissions(1236 collection_id,1237 sender.clone(),1238 ) {1239 None1240 } else if let Some(amount) = Self::owned_amount(1241 sender.clone(),1242 collection_id,1243 item_id,1244 ) {1245 Some(amount)1246 } else {1247 fail!(Error::<T>::NoPermission);1248 };12491250 if target_collection.access == AccessMode::WhiteList {1251 Self::check_white_list(collection_id, &sender)?;1252 Self::check_white_list(collection_id, &spender)?;1253 }12541255 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1256 let mut allowance: u128 = amount;1257 if allowance_exists {1258 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1259 }1260 if let Some(limit) = allowance_limit {1261 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1262 }1263 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12641265 Ok(())1266 }1267 1268 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1269 /// 1270 /// # Permissions1271 /// * Collection Owner1272 /// * Collection Admin1273 /// * Current NFT owner1274 /// * Address approved by current NFT owner1275 /// 1276 /// # Arguments1277 /// 1278 /// * from: Address that owns token.1279 /// 1280 /// * recipient: Address of token recipient.1281 /// 1282 /// * collection_id.1283 /// 1284 /// * item_id: ID of the item.1285 /// 1286 /// * value: Amount to transfer.1287 #[weight = <T as Config>::WeightInfo::transfer_from()]1288 #[transactional]1289 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12901291 let sender = ensure_signed(origin)?;1292 let mut appoved_transfer = false;12931294 // Check approval1295 let mut approval: u128 = 0;1296 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1297 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1298 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1299 appoved_transfer = true;1300 }13011302 let target_collection = <Collection<T>>::get(collection_id);13031304 // Limits check1305 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;13061307 // Transfer permissions check 1308 ensure!(1309 appoved_transfer || 1310 (1311 target_collection.limits.owner_can_transfer &&1312 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1313 ),1314 Error::<T>::NoPermission1315 );13161317 if target_collection.access == AccessMode::WhiteList {1318 Self::check_white_list(collection_id, &sender)?;1319 Self::check_white_list(collection_id, &recipient)?;1320 }13211322 // Reduce approval by transferred amount or remove if remaining approval drops to 01323 if approval.saturating_sub(value) > 0 {1324 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1325 }1326 else {1327 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1328 }13291330 match target_collection.mode1331 {1332 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1333 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1334 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1335 _ => ()1336 };13371338 Ok(())1339 }13401341 // #[weight = 0]1342 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13431344 // // let no_perm_mes = "You do not have permissions to modify this collection";1345 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1346 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1347 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13481349 // // // on_nft_received call13501351 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13521353 // Ok(())1354 // }13551356 /// Set off-chain data schema.1357 /// 1358 /// # Permissions1359 /// 1360 /// * Collection Owner1361 /// * Collection Admin1362 /// 1363 /// # Arguments1364 /// 1365 /// * collection_id.1366 /// 1367 /// * schema: String representing the offchain data schema.1368 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1369 #[transactional]1370 pub fn set_variable_meta_data (1371 origin,1372 collection_id: CollectionId,1373 item_id: TokenId,1374 data: Vec<u8>1375 ) -> DispatchResult {1376 let sender = ensure_signed(origin)?;1377 1378 Self::collection_exists(collection_id)?;1379 Self::token_exists(collection_id, item_id, &sender)?;13801381 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13821383 // Modify permissions check1384 let target_collection = <Collection<T>>::get(collection_id);1385 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1386 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1387 Error::<T>::NoPermission);13881389 match target_collection.mode1390 {1391 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1392 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1393 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1394 _ => fail!(Error::<T>::UnexpectedCollectionType)1395 };13961397 Ok(())1398 }1399 1400 /// Set schema standard1401 /// ImageURL1402 /// Unique1403 /// 1404 /// # Permissions1405 /// 1406 /// * Collection Owner1407 /// * Collection Admin1408 /// 1409 /// # Arguments1410 /// 1411 /// * collection_id.1412 /// 1413 /// * schema: SchemaVersion: enum1414 #[weight = <T as Config>::WeightInfo::set_schema_version()]1415 #[transactional]1416 pub fn set_schema_version(1417 origin,1418 collection_id: CollectionId,1419 version: SchemaVersion1420 ) -> DispatchResult {1421 let sender = ensure_signed(origin)?;1422 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1423 let mut target_collection = <Collection<T>>::get(collection_id);1424 target_collection.schema_version = version;1425 <Collection<T>>::insert(collection_id, target_collection);14261427 Ok(())1428 }14291430 /// Set off-chain data schema.1431 /// 1432 /// # Permissions1433 /// 1434 /// * Collection Owner1435 /// * Collection Admin1436 /// 1437 /// # Arguments1438 /// 1439 /// * collection_id.1440 /// 1441 /// * schema: String representing the offchain data schema.1442 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1443 #[transactional]1444 pub fn set_offchain_schema(1445 origin,1446 collection_id: CollectionId,1447 schema: Vec<u8>1448 ) -> DispatchResult {1449 let sender = ensure_signed(origin)?;1450 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14511452 // check schema limit1453 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14541455 let mut target_collection = <Collection<T>>::get(collection_id);1456 target_collection.offchain_schema = schema;1457 <Collection<T>>::insert(collection_id, target_collection);14581459 Ok(())1460 }14611462 /// Set const on-chain data schema.1463 /// 1464 /// # Permissions1465 /// 1466 /// * Collection Owner1467 /// * Collection Admin1468 /// 1469 /// # Arguments1470 /// 1471 /// * collection_id.1472 /// 1473 /// * schema: String representing the const on-chain data schema.1474 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1475 #[transactional]1476 pub fn set_const_on_chain_schema (1477 origin,1478 collection_id: CollectionId,1479 schema: Vec<u8>1480 ) -> DispatchResult {1481 let sender = ensure_signed(origin)?;1482 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14831484 // check schema limit1485 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14861487 let mut target_collection = <Collection<T>>::get(collection_id);1488 target_collection.const_on_chain_schema = schema;1489 <Collection<T>>::insert(collection_id, target_collection);14901491 Ok(())1492 }14931494 /// Set variable on-chain data schema.1495 /// 1496 /// # Permissions1497 /// 1498 /// * Collection Owner1499 /// * Collection Admin1500 /// 1501 /// # Arguments1502 /// 1503 /// * collection_id.1504 /// 1505 /// * schema: String representing the variable on-chain data schema.1506 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1507 #[transactional]1508 pub fn set_variable_on_chain_schema (1509 origin,1510 collection_id: CollectionId,1511 schema: Vec<u8>1512 ) -> DispatchResult {1513 let sender = ensure_signed(origin)?;1514 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;15151516 // check schema limit1517 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15181519 let mut target_collection = <Collection<T>>::get(collection_id);1520 target_collection.variable_on_chain_schema = schema;1521 <Collection<T>>::insert(collection_id, target_collection);15221523 Ok(())1524 }15251526 // Sudo permissions function1527 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1528 #[transactional]1529 pub fn set_chain_limits(1530 origin,1531 limits: ChainLimits1532 ) -> DispatchResult {15331534 #[cfg(not(feature = "runtime-benchmarks"))]1535 ensure_root(origin)?;15361537 <ChainLimit>::put(limits);1538 Ok(())1539 }15401541 /// Enable smart contract self-sponsoring.1542 /// 1543 /// # Permissions1544 /// 1545 /// * Contract Owner1546 /// 1547 /// # Arguments1548 /// 1549 /// * contract address1550 /// * enable flag1551 /// 1552 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1553 #[transactional]1554 pub fn enable_contract_sponsoring(1555 origin,1556 contract_address: T::AccountId,1557 enable: bool1558 ) -> DispatchResult {15591560 let sender = ensure_signed(origin)?;15611562 #[cfg(feature = "runtime-benchmarks")]1563 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15641565 Self::ensure_contract_owned(sender, &contract_address)?;15661567 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1568 Ok(())1569 }15701571 /// Set the rate limit for contract sponsoring to specified number of blocks.1572 /// 1573 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1574 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1575 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1576 /// from contract endowment if there are at least B blocks between such transactions. 1577 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1578 /// 1579 /// # Permissions1580 /// 1581 /// * Contract Owner1582 /// 1583 /// # Arguments1584 /// 1585 /// -`contract_address`: Address of the contract to sponsor1586 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1587 /// 1588 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1589 #[transactional]1590 pub fn set_contract_sponsoring_rate_limit(1591 origin,1592 contract_address: T::AccountId,1593 rate_limit: T::BlockNumber1594 ) -> DispatchResult {1595 let sender = ensure_signed(origin)?;15961597 #[cfg(feature = "runtime-benchmarks")]1598 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15991600 Self::ensure_contract_owned(sender, &contract_address)?;1601 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1602 Ok(())1603 }16041605 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1606 /// 1607 /// # Permissions1608 /// 1609 /// * Address that deployed smart contract.1610 /// 1611 /// # Arguments1612 /// 1613 /// -`contract_address`: Address of the contract.1614 /// 1615 /// - `enable`: . 1616 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1617 #[transactional]1618 pub fn toggle_contract_white_list(1619 origin,1620 contract_address: T::AccountId,1621 enable: bool1622 ) -> DispatchResult {1623 let sender = ensure_signed(origin)?;16241625 #[cfg(feature = "runtime-benchmarks")]1626 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16271628 Self::ensure_contract_owned(sender, &contract_address)?;1629 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1630 Ok(())1631 }1632 1633 /// Add an address to smart contract white list.1634 /// 1635 /// # Permissions1636 /// 1637 /// * Address that deployed smart contract.1638 /// 1639 /// # Arguments1640 /// 1641 /// -`contract_address`: Address of the contract.1642 ///1643 /// -`account_address`: Address to add.1644 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1645 #[transactional]1646 pub fn add_to_contract_white_list(1647 origin,1648 contract_address: T::AccountId,1649 account_address: T::AccountId1650 ) -> DispatchResult {1651 let sender = ensure_signed(origin)?;16521653 #[cfg(feature = "runtime-benchmarks")]1654 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1655 1656 Self::ensure_contract_owned(sender, &contract_address)?; 1657 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1658 Ok(())1659 }16601661 /// Remove an address from smart contract white list.1662 /// 1663 /// # Permissions1664 /// 1665 /// * Address that deployed smart contract.1666 /// 1667 /// # Arguments1668 /// 1669 /// -`contract_address`: Address of the contract.1670 ///1671 /// -`account_address`: Address to remove.1672 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1673 #[transactional]1674 pub fn remove_from_contract_white_list(1675 origin,1676 contract_address: T::AccountId,1677 account_address: T::AccountId1678 ) -> DispatchResult {1679 let sender = ensure_signed(origin)?;16801681 #[cfg(feature = "runtime-benchmarks")]1682 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16831684 Self::ensure_contract_owned(sender, &contract_address)?;1685 <ContractWhiteList<T>>::remove(contract_address, account_address);1686 Ok(())1687 }16881689 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1690 #[transactional]1691 pub fn set_collection_limits(1692 origin,1693 collection_id: u32,1694 new_limits: CollectionLimits,1695 ) -> DispatchResult {1696 let sender = ensure_signed(origin)?;1697 Self::check_owner_permissions(collection_id, sender.clone())?;1698 let mut target_collection = <Collection<T>>::get(collection_id);1699 let old_limits = target_collection.limits;1700 let chain_limits = ChainLimit::get();17011702 // collection bounds1703 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1704 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1705 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1706 Error::<T>::CollectionLimitBoundsExceeded);17071708 // token_limit check prev1709 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1710 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17111712 ensure!(1713 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1714 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1715 Error::<T>::OwnerPermissionsCantBeReverted,1716 );17171718 target_collection.limits = new_limits;1719 <Collection<T>>::insert(collection_id, target_collection);17201721 Ok(())1722 } 1723 }1724}17251726impl<T: Config> Module<T> {17271728 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17291730 let target_collection = <Collection<T>>::get(collection_id);17311732 // Limits check1733 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17341735 // Transfer permissions check1736 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1737 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1738 Error::<T>::NoPermission);17391740 if target_collection.access == AccessMode::WhiteList {1741 Self::check_white_list(collection_id, &sender)?;1742 Self::check_white_list(collection_id, &recipient)?;1743 }17441745 match target_collection.mode1746 {1747 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1748 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1749 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1750 _ => ()1751 };17521753 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17541755 Ok(())1756 }175717581759 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17601761 // check token limit and account token limit1762 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1763 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1764 1765 Ok(())1766 }17671768 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17691770 // check token limit and account token limit1771 let total_items: u32 = ItemListIndex::get(collection_id);1772 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1773 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1774 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17751776 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1777 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1778 Self::check_white_list(collection_id, owner)?;1779 Self::check_white_list(collection_id, sender)?;1780 }17811782 Ok(())1783 }17841785 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1786 match target_collection.mode1787 {1788 CollectionMode::NFT => {1789 if let CreateItemData::NFT(data) = data {1790 // check sizes1791 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1792 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1793 } else {1794 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1795 }1796 },1797 CollectionMode::Fungible(_) => {1798 if let CreateItemData::Fungible(_) = data {1799 } else {1800 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1801 }1802 },1803 CollectionMode::ReFungible => {1804 if let CreateItemData::ReFungible(data) = data {18051806 // check sizes1807 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1808 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18091810 // Check refungibility limits1811 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1812 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1813 } else {1814 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1815 }1816 },1817 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1818 };18191820 Ok(())1821 }18221823 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1824 match data1825 {1826 CreateItemData::NFT(data) => {1827 let item = NftItemType {1828 owner: owner.clone(),1829 const_data: data.const_data,1830 variable_data: data.variable_data1831 };18321833 Self::add_nft_item(collection_id, item)?;1834 },1835 CreateItemData::Fungible(data) => {1836 Self::add_fungible_item(collection_id, &owner, data.value)?;1837 },1838 CreateItemData::ReFungible(data) => {1839 let mut owner_list = Vec::new();1840 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18411842 let item = ReFungibleItemType {1843 owner: owner_list,1844 const_data: data.const_data,1845 variable_data: data.variable_data1846 };18471848 Self::add_refungible_item(collection_id, item)?;1849 }1850 };18511852 Ok(())1853 }18541855 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18561857 // Does new owner already have an account?1858 let mut balance: u128 = 0;1859 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1860 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1861 } 18621863 // Mint 1864 let item = FungibleItemType {1865 value: balance + value1866 };1867 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18681869 // Update balance1870 let new_balance = <Balance<T>>::get(collection_id, owner)1871 .checked_add(value)1872 .ok_or(Error::<T>::NumOverflow)?;1873 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18741875 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1876 Ok(())1877 }18781879 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1880 let current_index = <ItemListIndex>::get(collection_id)1881 .checked_add(1)1882 .ok_or(Error::<T>::NumOverflow)?;1883 let itemcopy = item.clone();18841885 ensure!(1886 item.owner.len() == 1,1887 Error::<T>::BadCreateRefungibleCall,1888 );1889 let item_owner = item.owner.first().expect("only one owner is defined");18901891 let value = item_owner.fraction;1892 let owner = item_owner.owner.clone();18931894 Self::add_token_index(collection_id, current_index, &owner)?;18951896 <ItemListIndex>::insert(collection_id, current_index);1897 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18981899 // Update balance1900 let new_balance = <Balance<T>>::get(collection_id, &owner)1901 .checked_add(value)1902 .ok_or(Error::<T>::NumOverflow)?;1903 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19041905 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1906 Ok(())1907 }19081909 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1910 let current_index = <ItemListIndex>::get(collection_id)1911 .checked_add(1)1912 .ok_or(Error::<T>::NumOverflow)?;19131914 let item_owner = item.owner.clone();1915 Self::add_token_index(collection_id, current_index, &item.owner)?;19161917 <ItemListIndex>::insert(collection_id, current_index);1918 <NftItemList<T>>::insert(collection_id, current_index, item);19191920 // Update balance1921 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1922 .checked_add(1)1923 .ok_or(Error::<T>::NumOverflow)?;1924 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19251926 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1927 Ok(())1928 }19291930 fn burn_refungible_item(1931 collection_id: CollectionId,1932 item_id: TokenId,1933 owner: &T::AccountId,1934 ) -> DispatchResult {1935 ensure!(1936 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1937 Error::<T>::TokenNotFound1938 );1939 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1940 let rft_balance = token1941 .owner1942 .iter()1943 .find(|&i| i.owner == *owner)1944 .ok_or(Error::<T>::TokenNotFound)?;1945 Self::remove_token_index(collection_id, item_id, owner)?;19461947 // update balance1948 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1949 .checked_sub(rft_balance.fraction)1950 .ok_or(Error::<T>::NumOverflow)?;1951 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19521953 // Re-create owners list with sender removed1954 let index = token1955 .owner1956 .iter()1957 .position(|i| i.owner == *owner)1958 .expect("owned item is exists");1959 token.owner.remove(index);1960 let owner_count = token.owner.len();19611962 // Burn the token completely if this was the last (only) owner1963 if owner_count == 0 {1964 <ReFungibleItemList<T>>::remove(collection_id, item_id);1965 }1966 else {1967 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1968 }19691970 Ok(())1971 }19721973 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1974 ensure!(1975 <NftItemList<T>>::contains_key(collection_id, item_id),1976 Error::<T>::TokenNotFound1977 );1978 let item = <NftItemList<T>>::get(collection_id, item_id);1979 Self::remove_token_index(collection_id, item_id, &item.owner)?;19801981 // update balance1982 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1983 .checked_sub(1)1984 .ok_or(Error::<T>::NumOverflow)?;1985 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1986 <NftItemList<T>>::remove(collection_id, item_id);19871988 Ok(())1989 }19901991 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1992 ensure!(1993 <FungibleItemList<T>>::contains_key(collection_id, owner),1994 Error::<T>::TokenNotFound1995 );1996 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1997 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19981999 // update balance2000 let new_balance = <Balance<T>>::get(collection_id, owner)2001 .checked_sub(value)2002 .ok_or(Error::<T>::NumOverflow)?;2003 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20042005 if balance.value - value > 0 {2006 balance.value -= value;2007 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2008 }2009 else {2010 <FungibleItemList<T>>::remove(collection_id, owner);2011 }20122013 Ok(())2014 }20152016 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2017 ensure!(2018 <Collection<T>>::contains_key(collection_id),2019 Error::<T>::CollectionNotFound2020 );2021 Ok(())2022 }20232024 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2025 Self::collection_exists(collection_id)?;20262027 let target_collection = <Collection<T>>::get(collection_id);2028 ensure!(2029 subject == target_collection.owner,2030 Error::<T>::NoPermission2031 );20322033 Ok(())2034 }20352036 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2037 let target_collection = <Collection<T>>::get(collection_id);2038 let mut result: bool = subject == target_collection.owner;2039 let exists = <AdminList<T>>::contains_key(collection_id);20402041 if !result & exists {2042 if <AdminList<T>>::get(collection_id).contains(&subject) {2043 result = true2044 }2045 }20462047 result2048 }20492050 fn check_owner_or_admin_permissions(2051 collection_id: CollectionId,2052 subject: T::AccountId,2053 ) -> DispatchResult {2054 Self::collection_exists(collection_id)?;2055 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20562057 ensure!(2058 result,2059 Error::<T>::NoPermission2060 );2061 Ok(())2062 }20632064 fn owned_amount(2065 subject: T::AccountId,2066 collection_id: CollectionId,2067 item_id: TokenId,2068 ) -> Option<u128> {2069 let target_collection = <Collection<T>>::get(collection_id);20702071 match target_collection.mode {2072 CollectionMode::NFT => {2073 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2074 return Some(1)2075 }2076 None2077 },2078 CollectionMode::Fungible(_) => {2079 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2080 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2081 .value);2082 }2083 None2084 },2085 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2086 .owner2087 .iter()2088 .find(|i| i.owner == subject)2089 .map(|i| i.fraction),2090 CollectionMode::Invalid => None,2091 }2092 }20932094 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2095 let target_collection = <Collection<T>>::get(collection_id);20962097 match target_collection.mode {2098 CollectionMode::NFT => {2099 <NftItemList<T>>::get(collection_id, item_id).owner == subject2100 }2101 CollectionMode::Fungible(_) => {2102 <FungibleItemList<T>>::contains_key(collection_id, &subject)2103 }2104 CollectionMode::ReFungible => {2105 <ReFungibleItemList<T>>::get(collection_id, item_id)2106 .owner2107 .iter()2108 .any(|i| i.owner == subject)2109 }2110 CollectionMode::Invalid => false,2111 }2112 }21132114 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2115 let mes = Error::<T>::AddresNotInWhiteList;2116 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21172118 Ok(())2119 }21202121 /// Check if token exists. In case of Fungible, check if there is an entry for 2122 /// the owner in fungible balances double map2123 fn token_exists(2124 collection_id: CollectionId,2125 item_id: TokenId,2126 owner: &T::AccountId2127 ) -> DispatchResult {2128 let target_collection = <Collection<T>>::get(collection_id);2129 let exists = match target_collection.mode2130 {2131 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2132 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2133 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2134 _ => false2135 };21362137 ensure!(exists == true, Error::<T>::TokenNotFound);2138 Ok(())2139 }21402141 fn transfer_fungible(2142 collection_id: CollectionId,2143 value: u128,2144 owner: &T::AccountId,2145 recipient: &T::AccountId,2146 ) -> DispatchResult {2147 Self::token_exists(collection_id, 0, owner)?;21482149 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2150 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21512152 // Send balance to recipient (updates balanceOf of recipient)2153 Self::add_fungible_item(collection_id, recipient, value)?;21542155 // update balanceOf of sender2156 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21572158 // Reduce or remove sender2159 if balance.value == value {2160 <FungibleItemList<T>>::remove(collection_id, owner);2161 }2162 else {2163 balance.value -= value;2164 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2165 }21662167 Ok(())2168 }21692170 fn transfer_refungible(2171 collection_id: CollectionId,2172 item_id: TokenId,2173 value: u128,2174 owner: T::AccountId,2175 new_owner: T::AccountId,2176 ) -> DispatchResult {2177 Self::token_exists(collection_id, item_id, &owner)?;21782179 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2180 let item = full_item2181 .owner2182 .iter()2183 .filter(|i| i.owner == owner)2184 .next()2185 .ok_or(Error::<T>::TokenNotFound)?;2186 let amount = item.fraction;21872188 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21892190 // update balance2191 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2192 .checked_sub(value)2193 .ok_or(Error::<T>::NumOverflow)?;2194 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21952196 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2197 .checked_add(value)2198 .ok_or(Error::<T>::NumOverflow)?;2199 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22002201 let old_owner = item.owner.clone();2202 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22032204 // transfer2205 if amount == value && !new_owner_has_account {2206 // change owner2207 // new owner do not have account2208 let mut new_full_item = full_item.clone();2209 new_full_item2210 .owner2211 .iter_mut()2212 .find(|i| i.owner == owner)2213 .expect("old owner does present in refungible")2214 .owner = new_owner.clone();2215 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22162217 // update index collection2218 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2219 } else {2220 let mut new_full_item = full_item.clone();2221 new_full_item2222 .owner2223 .iter_mut()2224 .find(|i| i.owner == owner)2225 .expect("old owner does present in refungible")2226 .fraction -= value;22272228 // separate amount2229 if new_owner_has_account {2230 // new owner has account2231 new_full_item2232 .owner2233 .iter_mut()2234 .find(|i| i.owner == new_owner)2235 .expect("new owner has account")2236 .fraction += value;2237 } else {2238 // new owner do not have account2239 new_full_item.owner.push(Ownership {2240 owner: new_owner.clone(),2241 fraction: value,2242 });2243 Self::add_token_index(collection_id, item_id, &new_owner)?;2244 }22452246 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2247 }22482249 Ok(())2250 }22512252 fn transfer_nft(2253 collection_id: CollectionId,2254 item_id: TokenId,2255 sender: T::AccountId,2256 new_owner: T::AccountId,2257 ) -> DispatchResult {2258 Self::token_exists(collection_id, item_id, &sender)?;22592260 let mut item = <NftItemList<T>>::get(collection_id, item_id);22612262 ensure!(2263 sender == item.owner,2264 Error::<T>::MustBeTokenOwner2265 );22662267 // update balance2268 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2269 .checked_sub(1)2270 .ok_or(Error::<T>::NumOverflow)?;2271 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22722273 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2274 .checked_add(1)2275 .ok_or(Error::<T>::NumOverflow)?;2276 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22772278 // change owner2279 let old_owner = item.owner.clone();2280 item.owner = new_owner.clone();2281 <NftItemList<T>>::insert(collection_id, item_id, item);22822283 // update index collection2284 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22852286 Ok(())2287 }2288 2289 fn set_re_fungible_variable_data(2290 collection_id: CollectionId,2291 item_id: TokenId,2292 data: Vec<u8>2293 ) -> DispatchResult {2294 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22952296 item.variable_data = data;22972298 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22992300 Ok(())2301 }23022303 fn set_nft_variable_data(2304 collection_id: CollectionId,2305 item_id: TokenId,2306 data: Vec<u8>2307 ) -> DispatchResult {2308 let mut item = <NftItemList<T>>::get(collection_id, item_id);2309 2310 item.variable_data = data;23112312 <NftItemList<T>>::insert(collection_id, item_id, item);2313 2314 Ok(())2315 }23162317 fn init_collection(item: &CollectionType<T::AccountId>) {2318 // check params2319 assert!(2320 item.decimal_points <= MAX_DECIMAL_POINTS,2321 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2322 );2323 assert!(2324 item.name.len() <= 64,2325 "Collection name can not be longer than 63 char"2326 );2327 assert!(2328 item.name.len() <= 256,2329 "Collection description can not be longer than 255 char"2330 );2331 assert!(2332 item.token_prefix.len() <= 16,2333 "Token prefix can not be longer than 15 char"2334 );23352336 // Generate next collection ID2337 let next_id = CreatedCollectionCount::get()2338 .checked_add(1)2339 .unwrap();23402341 CreatedCollectionCount::put(next_id);2342 }23432344 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2345 let current_index = <ItemListIndex>::get(collection_id)2346 .checked_add(1)2347 .unwrap();23482349 let item_owner = item.owner.clone();2350 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23512352 <ItemListIndex>::insert(collection_id, current_index);23532354 // Update balance2355 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2356 .checked_add(1)2357 .unwrap();2358 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2359 }23602361 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2362 let current_index = <ItemListIndex>::get(collection_id)2363 .checked_add(1)2364 .unwrap();23652366 Self::add_token_index(collection_id, current_index, owner).unwrap();23672368 <ItemListIndex>::insert(collection_id, current_index);23692370 // Update balance2371 let new_balance = <Balance<T>>::get(collection_id, owner)2372 .checked_add(item.value)2373 .unwrap();2374 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2375 }23762377 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2378 let current_index = <ItemListIndex>::get(collection_id)2379 .checked_add(1)2380 .unwrap();23812382 let value = item.owner.first().unwrap().fraction;2383 let owner = item.owner.first().unwrap().owner.clone();23842385 Self::add_token_index(collection_id, current_index, &owner).unwrap();23862387 <ItemListIndex>::insert(collection_id, current_index);23882389 // Update balance2390 let new_balance = <Balance<T>>::get(collection_id, &owner)2391 .checked_add(value)2392 .unwrap();2393 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2394 }23952396 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23972398 // add to account limit2399 if <AccountItemCount<T>>::contains_key(owner) {24002401 // bound Owned tokens by a single address2402 let count = <AccountItemCount<T>>::get(owner);2403 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24042405 <AccountItemCount<T>>::insert(owner.clone(), count2406 .checked_add(1)2407 .ok_or(Error::<T>::NumOverflow)?);2408 }2409 else {2410 <AccountItemCount<T>>::insert(owner.clone(), 1);2411 }24122413 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2414 if list_exists {2415 let mut list = <AddressTokens<T>>::get(collection_id, owner);2416 let item_contains = list.contains(&item_index.clone());24172418 if !item_contains {2419 list.push(item_index.clone());2420 }24212422 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2423 } else {2424 let mut itm = Vec::new();2425 itm.push(item_index.clone());2426 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2427 }24282429 Ok(())2430 }24312432 fn remove_token_index(2433 collection_id: CollectionId,2434 item_index: TokenId,2435 owner: &T::AccountId,2436 ) -> DispatchResult {24372438 // update counter2439 <AccountItemCount<T>>::insert(owner.clone(), 2440 <AccountItemCount<T>>::get(owner)2441 .checked_sub(1)2442 .ok_or(Error::<T>::NumOverflow)?);244324442445 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2446 if list_exists {2447 let mut list = <AddressTokens<T>>::get(collection_id, owner);2448 let item_contains = list.contains(&item_index.clone());24492450 if item_contains {2451 list.retain(|&item| item != item_index);2452 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2453 }2454 }24552456 Ok(())2457 }24582459 fn move_token_index(2460 collection_id: CollectionId,2461 item_index: TokenId,2462 old_owner: &T::AccountId,2463 new_owner: &T::AccountId,2464 ) -> DispatchResult {2465 Self::remove_token_index(collection_id, item_index, old_owner)?;2466 Self::add_token_index(collection_id, item_index, new_owner)?;24672468 Ok(())2469 }2470 2471 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2472 if <ContractOwner<T>>::contains_key(contract.clone()) {2473 let owner = <ContractOwner<T>>::get(contract);2474 ensure!(account == owner, Error::<T>::NoPermission);2475 } else {2476 fail!(Error::<T>::NoPermission);2477 }24782479 Ok(())2480 }2481}24822483////////////////////////////////////////////////////////////////////////////////////////////////////2484// Economic models2485// #region24862487/// Fee multiplier.2488pub type Multiplier = FixedU128;24892490type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;24912492/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2493/// in the queue.2494#[derive(Encode, Decode, Clone, Eq, PartialEq)]2495pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24962497impl<T: Config + Send + Sync> sp_std::fmt::Debug 2498 for ChargeTransactionPayment<T>2499{2500 #[cfg(feature = "std")]2501 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2502 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2503 }2504 #[cfg(not(feature = "std"))]2505 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2506 Ok(())2507 }2508}25092510impl<T: Config> ChargeTransactionPayment<T>2511where2512 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2513 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2514 T::AccountId: AsRef<[u8]>,2515 T::AccountId: UncheckedFrom<T::Hash>,2516{2517 fn traditional_fee(2518 len: usize,2519 info: &DispatchInfoOf<T::Call>,2520 tip: BalanceOf<T>,2521 ) -> BalanceOf<T>2522 where2523 T::Call: Dispatchable<Info = DispatchInfo>,2524 {2525 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2526 }25272528 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2529 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2530 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2531 let len_saturation = max_block_length as u64 / (len as u64).max(1);2532 let coefficient: BalanceOf<T> = weight_saturation2533 .min(len_saturation)2534 .saturated_into::<BalanceOf<T>>();2535 final_fee2536 .saturating_mul(coefficient)2537 .saturated_into::<TransactionPriority>()2538 }25392540 fn withdraw_fee(2541 &self,2542 who: &T::AccountId,2543 call: &T::Call,2544 info: &DispatchInfoOf<T::Call>,2545 len: usize,2546 ) -> Result<2547 (2548 BalanceOf<T>,2549 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2550 ),2551 TransactionValidityError,2552 > {2553 let tip = self.0;25542555 let fee = Self::traditional_fee(len, info, tip);25562557 // Only mess with balances if fee is not zero.2558 if fee.is_zero() {2559 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2560 .map(|i| (fee, i));2561 }25622563 // Determine who is paying transaction fee based on ecnomic model2564 // Parse call to extract collection ID and access collection sponsor2565 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2566 Some(Call::create_item(collection_id, _owner, _properties)) => {25672568 // sponsor timeout2569 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25702571 let collection = <Collection<T>>::get(collection_id);25722573 let limit = collection.limits.sponsor_transfer_timeout;2574 let mut sponsored = true;2575 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2576 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2577 let limit_time = last_tx_block + limit.into();2578 if block_number <= limit_time {2579 sponsored = false;2580 }2581 }2582 if sponsored {2583 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2584 }25852586 // check free create limit2587 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2588 (sponsored)2589 {2590 collection.sponsorship.sponsor()2591 .cloned()2592 .unwrap_or_default()2593 } else {2594 T::AccountId::default()2595 }2596 }2597 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2598 2599 let mut sponsor_transfer = false;2600 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {26012602 let collection_limits = <Collection<T>>::get(collection_id).limits;2603 let collection_mode = <Collection<T>>::get(collection_id).mode;2604 2605 // sponsor timeout2606 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2607 sponsor_transfer = match collection_mode {2608 CollectionMode::NFT => {2609 2610 // get correct limit2611 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2612 collection_limits.sponsor_transfer_timeout2613 } else {2614 ChainLimit::get().nft_sponsor_transfer_timeout2615 };2616 2617 let mut sponsored = true;2618 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2619 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2620 let limit_time = last_tx_block + limit.into();2621 if block_number <= limit_time {2622 sponsored = false;2623 }2624 }2625 if sponsored {2626 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2627 }26282629 sponsored2630 }2631 CollectionMode::Fungible(_) => {2632 2633 // get correct limit2634 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2635 collection_limits.sponsor_transfer_timeout2636 } else {2637 ChainLimit::get().fungible_sponsor_transfer_timeout2638 };2639 2640 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2641 let mut sponsored = true;2642 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2643 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2644 let limit_time = last_tx_block + limit.into();2645 if block_number <= limit_time {2646 sponsored = false;2647 }2648 }2649 if sponsored {2650 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2651 }26522653 sponsored2654 }2655 CollectionMode::ReFungible => {2656 2657 // get correct limit2658 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2659 collection_limits.sponsor_transfer_timeout2660 } else {2661 ChainLimit::get().refungible_sponsor_transfer_timeout2662 };2663 2664 let mut sponsored = true;2665 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2666 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2667 let limit_time = last_tx_block + limit.into();2668 if block_number <= limit_time {2669 sponsored = false;2670 }2671 }2672 if sponsored {2673 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2674 }26752676 sponsored2677 }2678 _ => {2679 false2680 },2681 };2682 }26832684 if !sponsor_transfer {2685 T::AccountId::default()2686 } else {2687 <Collection<T>>::get(collection_id).sponsorship.sponsor()2688 .cloned()2689 .unwrap_or_default()2690 }2691 }26922693 _ => T::AccountId::default(),2694 };26952696 // Sponsor smart contracts2697 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26982699 // On instantiation: set the contract owner2700 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27012702 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2703 &who,2704 code_hash,2705 salt,2706 );2707 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27082709 T::AccountId::default()2710 },27112712 // On instantiation with code: set the contract owner2713 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27142715 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2716 &who,2717 &T::Hashing::hash(&_code),2718 _salt,2719 );27202721 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27222723 T::AccountId::default()2724 }27252726 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2727 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27282729 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27302731 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2732 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2733 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2734 2735 if !owned_contract && white_list_enabled {2736 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2737 return Err(InvalidTransaction::Call.into());2738 }2739 }27402741 let mut sponsor_transfer = false;2742 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2743 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2744 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2745 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2746 let limit_time = last_tx_block + rate_limit;27472748 if block_number >= limit_time {2749 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2750 sponsor_transfer = true;2751 }2752 } else {2753 sponsor_transfer = false;2754 }2755 2756 2757 let mut sp = T::AccountId::default();2758 if sponsor_transfer {2759 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2760 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2761 sp = called_contract;2762 }2763 }2764 }27652766 sp2767 },27682769 _ => sponsor,2770 };27712772 let mut who_pays_fee: T::AccountId = sponsor.clone();2773 if sponsor == T::AccountId::default() {2774 who_pays_fee = who.clone();2775 }27762777 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2778 .map(|i| (fee, i))2779 }2780}278127822783impl<T: Config + Send + Sync> SignedExtension2784 for ChargeTransactionPayment<T>2785where2786 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2787 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2788 T::AccountId: AsRef<[u8]>,2789 T::AccountId: UncheckedFrom<T::Hash>,2790{2791 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2792 type AccountId = T::AccountId;2793 type Call = T::Call;2794 type AdditionalSigned = ();2795 type Pre = (2796 // tip2797 BalanceOf<T>,2798 // who pays fee2799 Self::AccountId,2800 // imbalance resulting from withdrawing the fee2801 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2802 );2803 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2804 Ok(())2805 }28062807 fn validate(2808 &self,2809 who: &Self::AccountId,2810 call: &Self::Call,2811 info: &DispatchInfoOf<Self::Call>,2812 len: usize,2813 ) -> TransactionValidity {2814 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2815 Ok(ValidTransaction {2816 priority: Self::get_priority(len, info, fee),2817 ..Default::default()2818 })2819 }28202821 fn pre_dispatch(2822 self,2823 who: &Self::AccountId,2824 call: &Self::Call,2825 info: &DispatchInfoOf<Self::Call>,2826 len: usize,2827 ) -> Result<Self::Pre, TransactionValidityError> {2828 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2829 Ok((self.0, who.clone(), imbalance))2830 }28312832 fn post_dispatch(2833 pre: Self::Pre,2834 info: &DispatchInfoOf<Self::Call>,2835 post_info: &PostDispatchInfoOf<Self::Call>,2836 len: usize,2837 _result: &DispatchResult,2838 ) -> Result<(), TransactionValidityError> {2839 let (tip, who, imbalance) = pre;2840 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2841 len as u32,2842 info,2843 post_info,2844 tip,2845 );2846 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2847 Ok(())2848 }2849}28502851// #endregiontests/src/creditFeesToTreasury.test.tsdiffbeforeafterboth--- a/tests/src/creditFeesToTreasury.test.ts
+++ b/tests/src/creditFeesToTreasury.test.ts
@@ -25,6 +25,7 @@
const Treasury = "5EYCAe5ijiYfyeZ2JJCGq56LmPyNRAKzpG4QkoQkkQNB5e6Z";
const saneMinimumFee = 0.05;
const saneMaximumFee = 0.5;
+const createCollectionDeposit = 100;
let alice: IKeyringPair;
let bob: IKeyringPair;
@@ -127,8 +128,8 @@
const aliceBalanceAfter = new BigNumber((await api.query.system.account(alicesPublicKey)).data.free.toString());
const fee = aliceBalanceBefore.minus(aliceBalanceAfter);
- expect(fee.dividedBy(1e15).toNumber()).to.be.lessThan(saneMaximumFee);
- expect(fee.dividedBy(1e15).toNumber()).to.be.greaterThan(saneMinimumFee);
+ expect(fee.dividedBy(1e15).toNumber()).to.be.lessThan(saneMaximumFee + createCollectionDeposit);
+ expect(fee.dividedBy(1e15).toNumber()).to.be.greaterThan(saneMinimumFee + createCollectionDeposit);
});
});