difftreelog
Merge fix
in: master
1 file changed
pallets/nft/src/lib.rsdiffbeforeafterboth1#![cfg_attr(not(feature = "std"), no_std)]23#[cfg(feature = "std")]4pub use std::*;56#[cfg(feature = "std")]7pub use serde::*;89use codec::{Decode, Encode};10pub use frame_support::{11 construct_runtime, decl_event, decl_module, decl_storage, decl_error,12 dispatch::DispatchResult,13 ensure, fail, parameter_types,14 traits::{15 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,16 Randomness, WithdrawReason,17 },18 weights::{19 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},20 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,21 WeightToFeePolynomial,22 },23 IsSubType, StorageValue,24};2526use frame_system::{self as system, ensure_signed, ensure_root};27use sp_runtime::sp_std::prelude::Vec;28use sp_runtime::{29 traits::{30 DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SignedExtension, Zero,31 },32 transaction_validity::{33 InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,34 },35 FixedPointOperand, FixedU128,36};37use pallet_contracts::ContractAddressFor;38use sp_runtime::traits::StaticLookup;3940#[cfg(test)]41mod mock;4243#[cfg(test)]44mod tests;4546mod default_weights;4748pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;4950// Structs51// #region5253pub type CollectionId = u32;54pub type TokenId = u32;5556pub type DecimalPoints = u8;5758#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]59#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]60pub enum CollectionMode {61 Invalid,62 NFT,63 // decimal points64 Fungible(DecimalPoints),65 // decimal points66 ReFungible(DecimalPoints),67}6869impl Into<u8> for CollectionMode {70 fn into(self) -> u8 {71 match self {72 CollectionMode::Invalid => 0,73 CollectionMode::NFT => 1,74 CollectionMode::Fungible(_) => 2,75 CollectionMode::ReFungible(_) => 3,76 }77 }78}7980#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]81#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]82pub enum AccessMode {83 Normal,84 WhiteList,85}86impl Default for AccessMode {87 fn default() -> Self {88 Self::Normal89 }90}9192impl Default for CollectionMode {93 fn default() -> Self {94 Self::Invalid95 }96}9798#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]99#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]100pub struct Ownership<AccountId> {101 pub owner: AccountId,102 pub fraction: u128,103}104105#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]106#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]107pub struct CollectionType<AccountId> {108 pub owner: AccountId,109 pub mode: CollectionMode,110 pub access: AccessMode,111 pub decimal_points: DecimalPoints,112 pub name: Vec<u16>, // 64 include null escape char113 pub description: Vec<u16>, // 256 include null escape char114 pub token_prefix: Vec<u8>, // 16 include null escape char115 pub mint_mode: bool,116 pub offchain_schema: Vec<u8>,117 pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender118 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship119 pub limits: CollectionLimits, // Collection private restrictions 120 pub variable_on_chain_schema: Vec<u8>, //121 pub const_on_chain_schema: Vec<u8>, //122}123124#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]125#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]126pub struct NftItemType<AccountId> {127 pub collection: CollectionId,128 pub owner: AccountId,129 pub const_data: Vec<u8>,130 pub variable_data: Vec<u8>,131}132133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]134#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]135pub struct FungibleItemType<AccountId> {136 pub collection: CollectionId,137 pub owner: AccountId,138 pub value: u128,139}140141#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]142#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]143pub struct ReFungibleItemType<AccountId> {144 pub collection: CollectionId,145 pub owner: Vec<Ownership<AccountId>>,146 pub const_data: Vec<u8>,147 pub variable_data: Vec<u8>,148}149150#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]151#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]152pub struct ApprovePermissions<AccountId> {153 pub approved: AccountId,154 pub amount: u128,155}156157#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]158#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]159pub struct VestingItem<AccountId, Moment> {160 pub sender: AccountId,161 pub recipient: AccountId,162 pub collection_id: CollectionId,163 pub item_id: TokenId,164 pub amount: u64,165 pub vesting_date: Moment,166}167168#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]169#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]170pub struct BasketItem<AccountId, BlockNumber> {171 pub address: AccountId,172 pub start_block: BlockNumber,173}174175#[derive(Encode, Decode, Debug, Clone, PartialEq)]176#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]177pub struct CollectionLimits {178 pub account_token_ownership_limit: u32,179 pub sponsored_data_size: u32,180 pub token_limit: u32,181182 // Timeouts for item types in passed blocks183 pub sponsor_transfer_timeout: u32,184}185186impl Default for CollectionLimits {187 fn default() -> CollectionLimits {188 CollectionLimits { 189 account_token_ownership_limit: u32::max_value(), 190 token_limit: u32::max_value(),191 sponsored_data_size: u32::max_value(), 192 sponsor_transfer_timeout: u32::max_value() }193 }194}195196#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]197#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]198pub struct ChainLimits {199 pub collection_numbers_limit: u32,200 pub account_token_ownership_limit: u32,201 pub collections_admins_limit: u64,202 pub custom_data_limit: u32,203204 // Timeouts for item types in passed blocks205 pub nft_sponsor_transfer_timeout: u32,206 pub fungible_sponsor_transfer_timeout: u32,207 pub refungible_sponsor_transfer_timeout: u32,208}209210pub trait WeightInfo {211 fn create_collection() -> Weight;212 fn destroy_collection() -> Weight;213 fn add_to_white_list() -> Weight;214 fn remove_from_white_list() -> Weight;215 fn set_public_access_mode() -> Weight;216 fn set_mint_permission() -> Weight;217 fn change_collection_owner() -> Weight;218 fn add_collection_admin() -> Weight;219 fn remove_collection_admin() -> Weight;220 fn set_collection_sponsor() -> Weight;221 fn confirm_sponsorship() -> Weight;222 fn remove_collection_sponsor() -> Weight;223 fn create_item(s: usize) -> Weight;224 fn burn_item() -> Weight;225 fn transfer() -> Weight;226 fn approve() -> Weight;227 fn transfer_from() -> Weight;228 fn set_offchain_schema() -> Weight;229 fn set_const_on_chain_schema() -> Weight;230 fn set_variable_on_chain_schema() -> Weight;231 fn set_variable_meta_data() -> Weight;232 fn enable_contract_sponsoring() -> Weight;233}234235#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CreateNftData {238 pub const_data: Vec<u8>,239 pub variable_data: Vec<u8>,240}241242#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]243#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]244pub struct CreateFungibleData {245}246247#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]248#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]249pub struct CreateReFungibleData {250 pub const_data: Vec<u8>,251 pub variable_data: Vec<u8>,252}253254#[derive(Encode, Decode, Debug, Clone, PartialEq)]255#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]256pub enum CreateItemData {257 NFT(CreateNftData),258 Fungible(CreateFungibleData),259 ReFungible(CreateReFungibleData)260}261262impl CreateItemData {263 pub fn len(&self) -> usize {264 let len = match self {265 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),266 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),267 _ => 0268 };269 270 return len;271 }272}273274impl From<CreateNftData> for CreateItemData {275 fn from(item: CreateNftData) -> Self {276 CreateItemData::NFT(item)277 }278}279280impl From<CreateReFungibleData> for CreateItemData {281 fn from(item: CreateReFungibleData) -> Self {282 CreateItemData::ReFungible(item)283 }284}285286impl From<CreateFungibleData> for CreateItemData {287 fn from(item: CreateFungibleData) -> Self {288 CreateItemData::Fungible(item)289 }290}291292293decl_error! {294 /// Error for non-fungible-token module.295 pub enum Error for Module<T: Trait> {296 /// Total collections bound exceeded.297 TotalCollectionsLimitExceeded,298 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.299 CollectionDecimalPointLimitExceeded, 300 /// Collection name can not be longer than 63 char.301 CollectionNameLimitExceeded, 302 /// Collection description can not be longer than 255 char.303 CollectionDescriptionLimitExceeded, 304 /// Token prefix can not be longer than 15 char.305 CollectionTokenPrefixLimitExceeded,306 /// This collection does not exist.307 CollectionNotFound,308 /// Item not exists.309 TokenNotFound,310 /// Arithmetic calculation overflow.311 NumOverflow, 312 /// Account already has admin role.313 AlreadyAdmin, 314 /// You do not own this collection.315 NoPermission,316 /// This address is not set as sponsor, use setCollectionSponsor first.317 ConfirmUnsetSponsorFail,318 /// Collection is not in mint mode.319 PublicMintingNotAllowed,320 /// Sender parameter and item owner must be equal.321 MustBeTokenOwner,322 /// Item balance not enough.323 TokenValueTooLow,324 /// Size of item is too large.325 NftSizeLimitExceeded,326 /// No approve found327 ApproveNotFound,328 /// Requested value more than approved.329 TokenValueNotEnough,330 /// Only approved addresses can call this method.331 ApproveRequired,332 /// Address is not in white list.333 AddresNotInWhiteList,334 /// Number of collection admins bound exceeded.335 CollectionAdminsLimitExceeded,336 /// Owned tokens by a single address bound exceeded.337 AddressOwnershipLimitExceeded,338 /// Length of items properties must be greater than 0.339 EmptyArgument,340 /// const_data exceeded data limit.341 TokenConstDataLimitExceeded,342 /// variable_data exceeded data limit.343 TokenVariableDataLimitExceeded,344 /// Not NFT item data used to mint in NFT collection.345 NotNftDataUsedToMintNftCollectionToken,346 /// Not Fungible item data used to mint in Fungible collection.347 NotFungibleDataUsedToMintFungibleCollectionToken,348 /// Not Re Fungible item data used to mint in Re Fungible collection.349 NotReFungibleDataUsedToMintReFungibleCollectionToken,350 /// Unexpected collection type.351 UnexpectedCollectionType,352 /// Can't store metadata in fungible tokens.353 CantStoreMetadataInFungibleTokens,354 /// Collection token limit exceeded355 CollectionTokenLimitExceeded,356 /// Account token limit exceeded per collection357 AccountTokenLimitExceeded358 }359}360361pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {362 type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;363364 /// Weight information for extrinsics in this pallet.365 type WeightInfo: WeightInfo;366}367368#[cfg(feature = "runtime-benchmarks")]369mod benchmarking;370371// #endregion372373decl_storage! {374 trait Store for Module<T: Trait> as Nft {375376 // Private members377 NextCollectionID: CollectionId;378 CreatedCollectionCount: u32;379 ChainVersion: u64;380 ItemListIndex: map hasher(identity) CollectionId => TokenId;381382 // Chain limits struct383 pub ChainLimit get(fn chain_limit) config(): ChainLimits;384385 // Bound counters386 CollectionCount: u32;387 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;388389 // Basic collections390 pub Collection get(fn collection) config(): map hasher(identity) CollectionId => CollectionType<T::AccountId>;391 pub AdminList get(fn admin_list_collection): map hasher(identity) CollectionId => Vec<T::AccountId>;392 pub WhiteList get(fn white_list): map hasher(identity) CollectionId => Vec<T::AccountId>;393394 /// Balance owner per collection map395 pub Balance get(fn balance_count): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => u128;396397 /// second parameter: item id + owner account id398 pub ApprovedList get(fn approved): double_map hasher(identity) CollectionId, hasher(twox_64_concat) (TokenId, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;399400 /// Item collections401 pub NftItemList get(fn nft_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => NftItemType<T::AccountId>;402 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => FungibleItemType<T::AccountId>;403 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(identity) CollectionId, hasher(identity) TokenId => ReFungibleItemType<T::AccountId>;404405 /// Index list406 pub AddressTokens get(fn address_tokens): double_map hasher(identity) CollectionId, hasher(twox_64_concat) T::AccountId => Vec<TokenId>;407408 /// Tokens transfer baskets409 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;410 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => Vec<BasketItem<T::AccountId, T::BlockNumber>>;411 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(identity) CollectionId, hasher(identity) TokenId => T::BlockNumber;412413 // Contract Sponsorship and Ownership414 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;415 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;416 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;417 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;418 }419 add_extra_genesis {420 build(|config: &GenesisConfig<T>| {421 // Modification of storage422 for (_num, _c) in &config.collection {423 <Module<T>>::init_collection(_c);424 }425426 for (_num, _q, _i) in &config.nft_item_id {427 <Module<T>>::init_nft_token(_i);428 }429430 for (_num, _q, _i) in &config.fungible_item_id {431 <Module<T>>::init_fungible_token(_i);432 }433434 for (_num, _q, _i) in &config.refungible_item_id {435 <Module<T>>::init_refungible_token(_i);436 }437 })438 }439}440441decl_event!(442 pub enum Event<T>443 where444 AccountId = <T as system::Trait>::AccountId,445 {446 /// New collection was created447 /// 448 /// # Arguments449 /// 450 /// * collection_id: Globally unique identifier of newly created collection.451 /// 452 /// * mode: [CollectionMode] converted into u8.453 /// 454 /// * account_id: Collection owner.455 Created(CollectionId, u8, AccountId),456457 /// New item was created.458 /// 459 /// # Arguments460 /// 461 /// * collection_id: Id of the collection where item was created.462 /// 463 /// * item_id: Id of an item. Unique within the collection.464 ItemCreated(CollectionId, TokenId),465466 /// Collection item was burned.467 /// 468 /// # Arguments469 /// 470 /// collection_id.471 /// 472 /// item_id: Identifier of burned NFT.473 ItemDestroyed(CollectionId, TokenId),474 }475);476477decl_module! {478 pub struct Module<T: Trait> for enum Call where origin: T::Origin {479480 fn deposit_event() = default;481 type Error = Error<T>;482483 fn on_initialize(now: T::BlockNumber) -> Weight {484485 if ChainVersion::get() < 2486 {487 let value = NextCollectionID::get();488 CreatedCollectionCount::put(value);489 ChainVersion::put(2);490 }491492 0493 }494495 /// 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.496 /// 497 /// # Permissions498 /// 499 /// * Anyone.500 /// 501 /// # Arguments502 /// 503 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.504 /// 505 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.506 /// 507 /// * token_prefix: UTF-8 string with token prefix.508 /// 509 /// * mode: [CollectionMode] collection type and type dependent data.510 // returns collection ID511 #[weight = T::WeightInfo::create_collection()]512 pub fn create_collection(origin,513 collection_name: Vec<u16>,514 collection_description: Vec<u16>,515 token_prefix: Vec<u8>,516 mode: CollectionMode) -> DispatchResult {517518 // Anyone can create a collection519 let who = ensure_signed(origin)?;520521 let decimal_points = match mode {522 CollectionMode::Fungible(points) => points,523 CollectionMode::ReFungible(points) => points,524 _ => 0525 };526527 // bound Total number of collections528 ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);529530 // check params531 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);532533 let mut name = collection_name.to_vec();534 name.push(0);535 ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);536537 let mut description = collection_description.to_vec();538 description.push(0);539 ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);540541 let mut prefix = token_prefix.to_vec();542 prefix.push(0);543 ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);544545 // Generate next collection ID546 let next_id = CreatedCollectionCount::get()547 .checked_add(1)548 .ok_or(Error::<T>::NumOverflow)?;549550 // bound counter551 let total = CollectionCount::get()552 .checked_add(1)553 .ok_or(Error::<T>::NumOverflow)?;554555 CreatedCollectionCount::put(next_id);556 CollectionCount::put(total);557558 // Create new collection559 let new_collection = CollectionType {560 owner: who.clone(),561 name: name,562 mode: mode.clone(),563 mint_mode: false,564 access: AccessMode::Normal,565 description: description,566 decimal_points: decimal_points,567 token_prefix: prefix,568 offchain_schema: Vec::new(),569 sponsor: T::AccountId::default(),570 unconfirmed_sponsor: T::AccountId::default(),571 variable_on_chain_schema: Vec::new(),572 const_on_chain_schema: Vec::new(),573 limits: CollectionLimits::default(),574 };575576 // Add new collection to map577 <Collection<T>>::insert(next_id, new_collection);578579 // call event580 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));581582 Ok(())583 }584585 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.586 /// 587 /// # Permissions588 /// 589 /// * Collection Owner.590 /// 591 /// # Arguments592 /// 593 /// * collection_id: collection to destroy.594 #[weight = T::WeightInfo::destroy_collection()]595 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {596597 let sender = ensure_signed(origin)?;598 Self::check_owner_permissions(collection_id, sender)?;599600 <AddressTokens<T>>::remove_prefix(collection_id);601 <ApprovedList<T>>::remove_prefix(collection_id);602 <Balance<T>>::remove_prefix(collection_id);603 <ItemListIndex>::remove(collection_id);604 <AdminList<T>>::remove(collection_id);605 <Collection<T>>::remove(collection_id);606 <WhiteList<T>>::remove(collection_id);607608 <NftItemList<T>>::remove_prefix(collection_id);609 <FungibleItemList<T>>::remove_prefix(collection_id);610 <ReFungibleItemList<T>>::remove_prefix(collection_id);611612 <NftTransferBasket<T>>::remove_prefix(collection_id);613 <FungibleTransferBasket<T>>::remove_prefix(collection_id);614 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);615616 if CollectionCount::get() > 0617 {618 // bound couter619 let total = CollectionCount::get()620 .checked_sub(1)621 .ok_or(Error::<T>::NumOverflow)?;622623 CollectionCount::put(total);624 }625626 Ok(())627 }628629 /// Add an address to white list.630 /// 631 /// # Permissions632 /// 633 /// * Collection Owner634 /// * Collection Admin635 /// 636 /// # Arguments637 /// 638 /// * collection_id.639 /// 640 /// * address.641 #[weight = T::WeightInfo::add_to_white_list()]642 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{643644 let sender = ensure_signed(origin)?;645 Self::check_owner_or_admin_permissions(collection_id, sender)?;646647 let mut white_list_collection: Vec<T::AccountId>;648 if <WhiteList<T>>::contains_key(collection_id) {649 white_list_collection = <WhiteList<T>>::get(collection_id);650 if !white_list_collection.contains(&address.clone())651 {652 white_list_collection.push(address.clone());653 }654 }655 else {656 white_list_collection = Vec::new();657 white_list_collection.push(address.clone());658 }659660 <WhiteList<T>>::insert(collection_id, white_list_collection);661 Ok(())662 }663664 /// Remove an address from white list.665 /// 666 /// # Permissions667 /// 668 /// * Collection Owner669 /// * Collection Admin670 /// 671 /// # Arguments672 /// 673 /// * collection_id.674 /// 675 /// * address.676 #[weight = T::WeightInfo::remove_from_white_list()]677 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{678679 let sender = ensure_signed(origin)?;680 Self::check_owner_or_admin_permissions(collection_id, sender)?;681682 if <WhiteList<T>>::contains_key(collection_id) {683 let mut white_list_collection = <WhiteList<T>>::get(collection_id);684 if white_list_collection.contains(&address.clone())685 {686 white_list_collection.retain(|i| *i != address.clone());687 <WhiteList<T>>::insert(collection_id, white_list_collection);688 }689 }690691 Ok(())692 }693694 /// Toggle between normal and white list access for the methods with access for `Anyone`.695 /// 696 /// # Permissions697 /// 698 /// * Collection Owner.699 /// 700 /// # Arguments701 /// 702 /// * collection_id.703 /// 704 /// * mode: [AccessMode]705 #[weight = T::WeightInfo::set_public_access_mode()]706 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult707 {708 let sender = ensure_signed(origin)?;709710 Self::check_owner_permissions(collection_id, sender)?;711 let mut target_collection = <Collection<T>>::get(collection_id);712 target_collection.access = mode;713 <Collection<T>>::insert(collection_id, target_collection);714715 Ok(())716 }717718 /// Allows Anyone to create tokens if:719 /// * White List is enabled, and720 /// * Address is added to white list, and721 /// * This method was called with True parameter722 /// 723 /// # Permissions724 /// * Collection Owner725 ///726 /// # Arguments727 /// 728 /// * collection_id.729 /// 730 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.731 #[weight = T::WeightInfo::set_mint_permission()]732 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult733 {734 let sender = ensure_signed(origin)?;735736 Self::check_owner_permissions(collection_id, sender)?;737 let mut target_collection = <Collection<T>>::get(collection_id);738 target_collection.mint_mode = mint_permission;739 <Collection<T>>::insert(collection_id, target_collection);740741 Ok(())742 }743744 /// Change the owner of the collection.745 /// 746 /// # Permissions747 /// 748 /// * Collection Owner.749 /// 750 /// # Arguments751 /// 752 /// * collection_id.753 /// 754 /// * new_owner.755 #[weight = T::WeightInfo::change_collection_owner()]756 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {757758 let sender = ensure_signed(origin)?;759 Self::check_owner_permissions(collection_id, sender)?;760 let mut target_collection = <Collection<T>>::get(collection_id);761 target_collection.owner = new_owner;762 <Collection<T>>::insert(collection_id, target_collection);763764 Ok(())765 }766767 /// Adds an admin of the Collection.768 /// 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. 769 /// 770 /// # Permissions771 /// 772 /// * Collection Owner.773 /// * Collection Admin.774 /// 775 /// # Arguments776 /// 777 /// * collection_id: ID of the Collection to add admin for.778 /// 779 /// * new_admin_id: Address of new admin to add.780 #[weight = T::WeightInfo::add_collection_admin()]781 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {782783 let sender = ensure_signed(origin)?;784 Self::check_owner_or_admin_permissions(collection_id, sender)?;785 let mut admin_arr: Vec<T::AccountId> = Vec::new();786787 if <AdminList<T>>::contains_key(collection_id)788 {789 admin_arr = <AdminList<T>>::get(collection_id);790 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);791 }792793 // Number of collection admins794 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);795796 admin_arr.push(new_admin_id);797 <AdminList<T>>::insert(collection_id, admin_arr);798799 Ok(())800 }801802 /// 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.803 ///804 /// # Permissions805 /// 806 /// * Collection Owner.807 /// * Collection Admin.808 /// 809 /// # Arguments810 /// 811 /// * collection_id: ID of the Collection to remove admin for.812 /// 813 /// * account_id: Address of admin to remove.814 #[weight = T::WeightInfo::remove_collection_admin()]815 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {816817 let sender = ensure_signed(origin)?;818 Self::check_owner_or_admin_permissions(collection_id, sender)?;819820 if <AdminList<T>>::contains_key(collection_id)821 {822 let mut admin_arr = <AdminList<T>>::get(collection_id);823 admin_arr.retain(|i| *i != account_id);824 <AdminList<T>>::insert(collection_id, admin_arr);825 }826827 Ok(())828 }829830 /// # Permissions831 /// 832 /// * Collection Owner833 /// 834 /// # Arguments835 /// 836 /// * collection_id.837 /// 838 /// * new_sponsor.839 #[weight = T::WeightInfo::set_collection_sponsor()]840 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {841842 let sender = ensure_signed(origin)?;843 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);844845 let mut target_collection = <Collection<T>>::get(collection_id);846 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);847848 target_collection.unconfirmed_sponsor = new_sponsor;849 <Collection<T>>::insert(collection_id, target_collection);850851 Ok(())852 }853854 /// # Permissions855 /// 856 /// * Sponsor.857 /// 858 /// # Arguments859 /// 860 /// * collection_id.861 #[weight = T::WeightInfo::confirm_sponsorship()]862 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {863864 let sender = ensure_signed(origin)?;865 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);866867 let mut target_collection = <Collection<T>>::get(collection_id);868 ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);869870 target_collection.sponsor = target_collection.unconfirmed_sponsor;871 target_collection.unconfirmed_sponsor = T::AccountId::default();872 <Collection<T>>::insert(collection_id, target_collection);873874 Ok(())875 }876877 /// Switch back to pay-per-own-transaction model.878 ///879 /// # Permissions880 ///881 /// * Collection owner.882 /// 883 /// # Arguments884 /// 885 /// * collection_id.886 #[weight = T::WeightInfo::remove_collection_sponsor()]887 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {888889 let sender = ensure_signed(origin)?;890 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);891892 let mut target_collection = <Collection<T>>::get(collection_id);893 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);894895 target_collection.sponsor = T::AccountId::default();896 <Collection<T>>::insert(collection_id, target_collection);897898 Ok(())899 }900901 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.902 /// 903 /// # Permissions904 /// 905 /// * Collection Owner.906 /// * Collection Admin.907 /// * Anyone if908 /// * White List is enabled, and909 /// * Address is added to white list, and910 /// * MintPermission is enabled (see SetMintPermission method)911 /// 912 /// # Arguments913 /// 914 /// * collection_id: ID of the collection.915 /// 916 /// * owner: Address, initial owner of the NFT.917 ///918 /// * data: Token data to store on chain.919 // #[weight =920 // (130_000_000 as Weight)921 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))922 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))923 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]924925 #[weight = T::WeightInfo::create_item(data.len())]926 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {927928 let sender = ensure_signed(origin)?;929930 Self::collection_exists(collection_id)?;931932 let target_collection = <Collection<T>>::get(collection_id);933934 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;935 Self::validate_create_item_args(&target_collection, &data)?;936 Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;937938 Ok(())939 }940941 /// This method creates multiple instances of NFT Collection created with CreateCollection method.942 /// 943 /// # Permissions944 /// 945 /// * Collection Owner.946 /// * Collection Admin.947 /// * Anyone if948 /// * White List is enabled, and949 /// * Address is added to white list, and950 /// * MintPermission is enabled (see SetMintPermission method)951 /// 952 /// # Arguments953 /// 954 /// * collection_id: ID of the collection.955 /// 956 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].957 /// 958 /// * owner: Address, initial owner of the NFT.959 #[weight = T::WeightInfo::create_item(items_data.into_iter()960 .map(|data| { data.len() })961 .sum())]962 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {963964 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);965 let sender = ensure_signed(origin)?;966967 Self::collection_exists(collection_id)?;968 let target_collection = <Collection<T>>::get(collection_id);969970 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;971972 for data in &items_data {973 Self::validate_create_item_args(&target_collection, data)?;974 }975 for data in &items_data {976 Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;977 }978979 Ok(())980 }981982 /// Destroys a concrete instance of NFT.983 /// 984 /// # Permissions985 /// 986 /// * Collection Owner.987 /// * Collection Admin.988 /// * Current NFT Owner.989 /// 990 /// # Arguments991 /// 992 /// * collection_id: ID of the collection.993 /// 994 /// * item_id: ID of NFT to burn.995 #[weight = T::WeightInfo::burn_item()]996 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId) -> DispatchResult {997998 let sender = ensure_signed(origin)?;999 Self::collection_exists(collection_id)?;10001001 // Transfer permissions check1002 let target_collection = <Collection<T>>::get(collection_id);1003 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1004 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1005 Error::<T>::NoPermission);10061007 if target_collection.access == AccessMode::WhiteList {1008 Self::check_white_list(collection_id, &sender)?;1009 }10101011 match target_collection.mode1012 {1013 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1014 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection_id, item_id)?,1015 CollectionMode::ReFungible(_) => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,1016 _ => ()1017 };10181019 // call event1020 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));10211022 Ok(())1023 }10241025 /// Change ownership of the token.1026 /// 1027 /// # Permissions1028 /// 1029 /// * Collection Owner1030 /// * Collection Admin1031 /// * Current NFT owner1032 ///1033 /// # Arguments1034 /// 1035 /// * recipient: Address of token recipient.1036 /// 1037 /// * collection_id.1038 /// 1039 /// * item_id: ID of the item1040 /// * Non-Fungible Mode: Required.1041 /// * Fungible Mode: Ignored.1042 /// * Re-Fungible Mode: Required.1043 /// 1044 /// * value: Amount to transfer.1045 /// * Non-Fungible Mode: Ignored1046 /// * Fungible Mode: Must specify transferred amount1047 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1048 #[weight = T::WeightInfo::transfer()]1049 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {10501051 let sender = ensure_signed(origin)?;1052 let target_collection = <Collection<T>>::get(collection_id);10531054 // Limits check1055 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;10561057 // Transfer permissions check1058 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1059 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1060 Error::<T>::NoPermission);10611062 if target_collection.access == AccessMode::WhiteList {1063 Self::check_white_list(collection_id, &sender)?;1064 Self::check_white_list(collection_id, &recipient)?;1065 }10661067 match target_collection.mode1068 {1069 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1070 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1071 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1072 _ => ()1073 };10741075 Ok(())1076 }10771078 /// Set, change, or remove approved address to transfer the ownership of the NFT.1079 /// 1080 /// # Permissions1081 /// 1082 /// * Collection Owner1083 /// * Collection Admin1084 /// * Current NFT owner1085 /// 1086 /// # Arguments1087 /// 1088 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1089 /// 1090 /// * collection_id.1091 /// 1092 /// * item_id: ID of the item.1093 #[weight = T::WeightInfo::approve()]1094 pub fn approve(origin, approved: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> DispatchResult {10951096 let sender = ensure_signed(origin)?;10971098 // Transfer permissions check1099 let target_collection = <Collection<T>>::get(collection_id);1100 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1101 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1102 Error::<T>::NoPermission);11031104 if target_collection.access == AccessMode::WhiteList {1105 Self::check_white_list(collection_id, &sender)?;1106 Self::check_white_list(collection_id, &approved)?;1107 }11081109 // amount param stub1110 let amount = 100000000;11111112 let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1113 if list_exists {11141115 let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1116 let item_contains = list.iter().any(|i| i.approved == approved);11171118 if !item_contains {1119 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1120 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1121 }1122 } else {11231124 let mut list = Vec::new();1125 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1126 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1127 }11281129 Ok(())1130 }1131 1132 /// 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.1133 /// 1134 /// # Permissions1135 /// * Collection Owner1136 /// * Collection Admin1137 /// * Current NFT owner1138 /// * Address approved by current NFT owner1139 /// 1140 /// # Arguments1141 /// 1142 /// * from: Address that owns token.1143 /// 1144 /// * recipient: Address of token recipient.1145 /// 1146 /// * collection_id.1147 /// 1148 /// * item_id: ID of the item.1149 /// 1150 /// * value: Amount to transfer.1151 #[weight = T::WeightInfo::transfer_from()]1152 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {11531154 let sender = ensure_signed(origin)?;1155 let mut appoved_transfer = false;11561157 // Check approve1158 if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1159 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1160 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1161 if opt_item.is_some()1162 {1163 appoved_transfer = true;1164 ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1165 }1166 }11671168 let target_collection = <Collection<T>>::get(collection_id);11691170 // Limits check1171 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;11721173 // Transfer permissions check 1174 ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1175 Error::<T>::NoPermission);11761177 if target_collection.access == AccessMode::WhiteList {1178 Self::check_white_list(collection_id, &sender)?;1179 Self::check_white_list(collection_id, &recipient)?;1180 }11811182 // remove approve1183 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1184 .into_iter().filter(|i| i.approved != sender.clone()).collect();1185 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);118611871188 match target_collection.mode1189 {1190 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1191 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1192 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1193 _ => ()1194 };11951196 Ok(())1197 }11981199 ///1200 #[weight = 0]1201 pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12021203 // let no_perm_mes = "You do not have permissions to modify this collection";1204 // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1205 // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1206 // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12071208 // // on_nft_received call12091210 // Self::transfer(origin, collection_id, item_id, new_owner)?;12111212 Ok(())1213 }12141215 /// Set off-chain data schema.1216 /// 1217 /// # Permissions1218 /// 1219 /// * Collection Owner1220 /// * Collection Admin1221 /// 1222 /// # Arguments1223 /// 1224 /// * collection_id.1225 /// 1226 /// * schema: String representing the offchain data schema.1227 #[weight = T::WeightInfo::set_variable_meta_data()]1228 pub fn set_variable_meta_data (1229 origin,1230 collection_id: CollectionId,1231 item_id: TokenId,1232 data: Vec<u8>1233 ) -> DispatchResult {1234 let sender = ensure_signed(origin)?;1235 1236 Self::collection_exists(collection_id)?;1237 1238 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);12391240 // Modify permissions check1241 let target_collection = <Collection<T>>::get(collection_id);1242 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1243 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1244 Error::<T>::NoPermission);12451246 Self::item_exists(collection_id, item_id, &target_collection.mode)?;12471248 match target_collection.mode1249 {1250 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1251 CollectionMode::ReFungible(_) => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1252 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1253 _ => fail!(Error::<T>::UnexpectedCollectionType)1254 };12551256 Ok(())1257 }1258 12591260 /// Set off-chain data schema.1261 /// 1262 /// # Permissions1263 /// 1264 /// * Collection Owner1265 /// * Collection Admin1266 /// 1267 /// # Arguments1268 /// 1269 /// * collection_id.1270 /// 1271 /// * schema: String representing the offchain data schema.1272 #[weight = T::WeightInfo::set_offchain_schema()]1273 pub fn set_offchain_schema(1274 origin,1275 collection_id: CollectionId,1276 schema: Vec<u8>1277 ) -> DispatchResult {1278 let sender = ensure_signed(origin)?;1279 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12801281 let mut target_collection = <Collection<T>>::get(collection_id);1282 target_collection.offchain_schema = schema;1283 <Collection<T>>::insert(collection_id, target_collection);12841285 Ok(())1286 }12871288 /// Set const on-chain data schema.1289 /// 1290 /// # Permissions1291 /// 1292 /// * Collection Owner1293 /// * Collection Admin1294 /// 1295 /// # Arguments1296 /// 1297 /// * collection_id.1298 /// 1299 /// * schema: String representing the const on-chain data schema.1300 #[weight = T::WeightInfo::set_const_on_chain_schema()]1301 pub fn set_const_on_chain_schema (1302 origin,1303 collection_id: CollectionId,1304 schema: Vec<u8>1305 ) -> DispatchResult {1306 let sender = ensure_signed(origin)?;1307 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13081309 let mut target_collection = <Collection<T>>::get(collection_id);1310 target_collection.const_on_chain_schema = schema;1311 <Collection<T>>::insert(collection_id, target_collection);13121313 Ok(())1314 }13151316 /// Set variable on-chain data schema.1317 /// 1318 /// # Permissions1319 /// 1320 /// * Collection Owner1321 /// * Collection Admin1322 /// 1323 /// # Arguments1324 /// 1325 /// * collection_id.1326 /// 1327 /// * schema: String representing the variable on-chain data schema.1328 #[weight = T::WeightInfo::set_const_on_chain_schema()]1329 pub fn set_variable_on_chain_schema (1330 origin,1331 collection_id: CollectionId,1332 schema: Vec<u8>1333 ) -> DispatchResult {1334 let sender = ensure_signed(origin)?;1335 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;13361337 let mut target_collection = <Collection<T>>::get(collection_id);1338 target_collection.variable_on_chain_schema = schema;1339 <Collection<T>>::insert(collection_id, target_collection);13401341 Ok(())1342 }13431344 // Sudo permissions function1345 #[weight = 0]1346 pub fn set_chain_limits(1347 origin,1348 limits: ChainLimits1349 ) -> DispatchResult {1350 ensure_root(origin)?;1351 <ChainLimit>::put(limits);1352 Ok(())1353 }13541355 /// Enable smart contract self-sponsoring.1356 /// 1357 /// # Permissions1358 /// 1359 /// * Contract Owner1360 /// 1361 /// # Arguments1362 /// 1363 /// * contract address1364 /// * enable flag1365 /// 1366 #[weight = T::WeightInfo::enable_contract_sponsoring()]1367 pub fn enable_contract_sponsoring(1368 origin,1369 contract_address: T::AccountId,1370 enable: bool1371 ) -> DispatchResult {13721373 let sender = ensure_signed(origin)?;13741375 #[cfg(feature = "runtime-benchmarks")]1376 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13771378 let mut is_owner = false;1379 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1380 let owner = <ContractOwner<T>>::get(&contract_address);1381 is_owner = sender == owner;1382 }1383 ensure!(is_owner, Error::<T>::NoPermission);13841385 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1386 Ok(())1387 }13881389 /// Set the rate limit for contract sponsoring to specified number of blocks.1390 /// 1391 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1392 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1393 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1394 /// from contract endowment if there are at least B blocks between such transactions. 1395 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1396 /// 1397 /// # Permissions1398 /// 1399 /// * Contract Owner1400 /// 1401 /// # Arguments1402 /// 1403 /// -`contract_address`: Address of the contract to sponsor1404 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1405 /// 1406 #[weight = 0]1407 pub fn set_contract_sponsoring_rate_limit(1408 origin,1409 contract_address: T::AccountId,1410 rate_limit: T::BlockNumber1411 ) -> DispatchResult {1412 let sender = ensure_signed(origin)?;1413 let mut is_owner = false;1414 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1415 let owner = <ContractOwner<T>>::get(&contract_address);1416 is_owner = sender == owner;1417 }1418 ensure!(is_owner, Error::<T>::NoPermission);14191420 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1421 Ok(())1422 }14231424 #[weight = 0]1425 pub fn set_collection_limits(1426 origin,1427 collection_id: u32,1428 limits: CollectionLimits,1429 ) -> DispatchResult {1430 let sender = ensure_signed(origin)?;1431 Self::check_owner_permissions(collection_id, sender.clone())?;1432 let mut target_collection = <Collection<T>>::get(collection_id);1433 let chain_limits = ChainLimit::get();1434 let climits = target_collection.limits;14351436 // token_limit check prev1437 ensure!(climits.token_limit > limits.token_limit && 1438 climits.token_limit <= chain_limits.account_token_ownership_limit, 1439 Error::<T>::AccountTokenLimitExceeded);14401441 target_collection.limits = limits;1442 <Collection<T>>::insert(collection_id, target_collection);14431444 Ok(())1445 } 1446 }1447}14481449impl<T: Trait> Module<T> {14501451 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {14521453 if !Self::is_owner_or_admin_permissions(collection_id, recipient.clone()) {14541455 // check token limit and account token limit1456 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1457 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1458 }14591460 Ok(())1461 }14621463 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {14641465 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {14661467 // check token limit and account token limit1468 let total_items: u32 = ItemListIndex::get(collection_id);1469 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1470 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1471 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1472 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1473 Self::check_white_list(collection_id, owner)?;1474 Self::check_white_list(collection_id, sender)?;1475 }14761477 Ok(())1478 }14791480 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1481 match target_collection.mode1482 {1483 CollectionMode::NFT => {1484 if let CreateItemData::NFT(data) = data {1485 // check sizes1486 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1487 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1488 } else {1489 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1490 }1491 },1492 CollectionMode::Fungible(_) => {1493 if let CreateItemData::Fungible(_) = data {1494 } else {1495 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1496 }1497 },1498 CollectionMode::ReFungible(_) => {1499 if let CreateItemData::ReFungible(data) = data {15001501 // check sizes1502 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1503 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1504 } else {1505 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1506 }1507 },1508 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1509 };15101511 Ok(())1512 }15131514 fn create_item_no_validation(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1515 match data1516 {1517 CreateItemData::NFT(data) => {1518 let item = NftItemType {1519 collection: collection_id,1520 owner,1521 const_data: data.const_data,1522 variable_data: data.variable_data1523 };15241525 Self::add_nft_item(item)?;1526 },1527 CreateItemData::Fungible(_) => {1528 let item = FungibleItemType {1529 collection: collection_id,1530 owner,1531 value: (10 as u128).pow(collection.decimal_points as u32)1532 };15331534 Self::add_fungible_item(item)?;1535 },1536 CreateItemData::ReFungible(data) => {1537 let mut owner_list = Vec::new();1538 let value = (10 as u128).pow(collection.decimal_points as u32);1539 owner_list.push(Ownership {owner: owner.clone(), fraction: value});15401541 let item = ReFungibleItemType {1542 collection: collection_id,1543 owner: owner_list,1544 const_data: data.const_data,1545 variable_data: data.variable_data1546 };15471548 Self::add_refungible_item(item)?;1549 }1550 };15511552 // call event1553 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));15541555 Ok(())1556 }15571558 fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1559 let current_index = <ItemListIndex>::get(item.collection)1560 .checked_add(1)1561 .ok_or(Error::<T>::NumOverflow)?;1562 let itemcopy = item.clone();1563 let owner = item.owner.clone();15641565 Self::add_token_index(item.collection, current_index, owner.clone())?;15661567 <ItemListIndex>::insert(item.collection, current_index);1568 <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);15691570 // Add current block1571 let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1572 <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1573 1574 // Update balance1575 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1576 .checked_add(item.value)1577 .ok_or(Error::<T>::NumOverflow)?;1578 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);15791580 Ok(())1581 }15821583 fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1584 let current_index = <ItemListIndex>::get(item.collection)1585 .checked_add(1)1586 .ok_or(Error::<T>::NumOverflow)?;1587 let itemcopy = item.clone();15881589 let value = item.owner.first().unwrap().fraction;1590 let owner = item.owner.first().unwrap().owner.clone();15911592 Self::add_token_index(item.collection, current_index, owner.clone())?;15931594 <ItemListIndex>::insert(item.collection, current_index);1595 <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);15961597 // Add current block1598 let block_number: T::BlockNumber = 0.into();1599 <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);16001601 // Update balance1602 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1603 .checked_add(value)1604 .ok_or(Error::<T>::NumOverflow)?;1605 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);16061607 Ok(())1608 }16091610 fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1611 let current_index = <ItemListIndex>::get(item.collection)1612 .checked_add(1)1613 .ok_or(Error::<T>::NumOverflow)?;16141615 let item_owner = item.owner.clone();1616 let collection_id = item.collection.clone();1617 Self::add_token_index(collection_id, current_index, item.owner.clone())?;16181619 <ItemListIndex>::insert(collection_id, current_index);1620 <NftItemList<T>>::insert(collection_id, current_index, item);16211622 // Add current block1623 let block_number: T::BlockNumber = 0.into();1624 <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);16251626 // Update balance1627 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1628 .checked_add(1)1629 .ok_or(Error::<T>::NumOverflow)?;1630 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);16311632 Ok(())1633 }16341635 fn burn_refungible_item(1636 collection_id: CollectionId,1637 item_id: TokenId,1638 owner: T::AccountId,1639 ) -> DispatchResult {1640 ensure!(1641 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1642 Error::<T>::TokenNotFound1643 );1644 let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1645 let item = collection1646 .owner1647 .iter()1648 .filter(|&i| i.owner == owner)1649 .next()1650 .unwrap();1651 Self::remove_token_index(collection_id, item_id, owner.clone())?;16521653 // remove approve list1654 <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));16551656 // update balance1657 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1658 .checked_sub(item.fraction)1659 .ok_or(Error::<T>::NumOverflow)?;1660 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);16611662 <ReFungibleItemList<T>>::remove(collection_id, item_id);16631664 Ok(())1665 }16661667 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1668 ensure!(1669 <NftItemList<T>>::contains_key(collection_id, item_id),1670 Error::<T>::TokenNotFound1671 );1672 let item = <NftItemList<T>>::get(collection_id, item_id);1673 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;16741675 // remove approve list1676 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));16771678 // update balance1679 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1680 .checked_sub(1)1681 .ok_or(Error::<T>::NumOverflow)?;1682 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1683 <NftItemList<T>>::remove(collection_id, item_id);16841685 Ok(())1686 }16871688 fn burn_fungible_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1689 ensure!(1690 <FungibleItemList<T>>::contains_key(collection_id, item_id),1691 Error::<T>::TokenNotFound1692 );1693 let item = <FungibleItemList<T>>::get(collection_id, item_id);1694 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;16951696 // remove approve list1697 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));16981699 // update balance1700 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1701 .checked_sub(item.value)1702 .ok_or(Error::<T>::NumOverflow)?;1703 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);17041705 <FungibleItemList<T>>::remove(collection_id, item_id);17061707 Ok(())1708 }17091710 fn collection_exists(collection_id: CollectionId) -> DispatchResult {1711 ensure!(1712 <Collection<T>>::contains_key(collection_id),1713 Error::<T>::CollectionNotFound1714 );1715 Ok(())1716 }17171718 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {1719 Self::collection_exists(collection_id)?;17201721 let target_collection = <Collection<T>>::get(collection_id);1722 ensure!(1723 subject == target_collection.owner,1724 Error::<T>::NoPermission1725 );17261727 Ok(())1728 }17291730 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {1731 let target_collection = <Collection<T>>::get(collection_id);1732 let mut result: bool = subject == target_collection.owner;1733 let exists = <AdminList<T>>::contains_key(collection_id);17341735 if !result & exists {1736 if <AdminList<T>>::get(collection_id).contains(&subject) {1737 result = true1738 }1739 }17401741 result1742 }17431744 fn check_owner_or_admin_permissions(1745 collection_id: CollectionId,1746 subject: T::AccountId,1747 ) -> DispatchResult {1748 Self::collection_exists(collection_id)?;1749 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());17501751 ensure!(1752 result,1753 Error::<T>::NoPermission1754 );1755 Ok(())1756 }17571758 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {1759 let target_collection = <Collection<T>>::get(collection_id);17601761 match target_collection.mode {1762 CollectionMode::NFT => {1763 <NftItemList<T>>::get(collection_id, item_id).owner == subject1764 }1765 CollectionMode::Fungible(_) => {1766 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1767 }1768 CollectionMode::ReFungible(_) => {1769 <ReFungibleItemList<T>>::get(collection_id, item_id)1770 .owner1771 .iter()1772 .any(|i| i.owner == subject)1773 }1774 CollectionMode::Invalid => false,1775 }1776 }17771778 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {1779 let mes = Error::<T>::AddresNotInWhiteList;1780 ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1781 let wl = <WhiteList<T>>::get(collection_id);1782 ensure!(wl.contains(address), mes);17831784 Ok(())1785 }17861787 fn transfer_fungible(1788 collection_id: CollectionId,1789 item_id: TokenId,1790 value: u128,1791 owner: T::AccountId,1792 new_owner: T::AccountId,1793 ) -> DispatchResult {1794 ensure!(1795 <FungibleItemList<T>>::contains_key(collection_id, item_id),1796 Error::<T>::TokenNotFound1797 );17981799 let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1800 let amount = full_item.value;18011802 ensure!(amount >= value, Error::<T>::TokenValueTooLow);18031804 // update balance1805 let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1806 .checked_sub(value)1807 .ok_or(Error::<T>::NumOverflow)?;1808 <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);18091810 let mut new_owner_account_id = 0;1811 let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1812 if new_owner_items.len() > 0 {1813 new_owner_account_id = new_owner_items[0];1814 }18151816 // transfer1817 if amount == value && new_owner_account_id == 0 {1818 // change owner1819 // new owner do not have account1820 let mut new_full_item = full_item.clone();1821 new_full_item.owner = new_owner.clone();1822 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);18231824 // update balance1825 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1826 .checked_add(value)1827 .ok_or(Error::<T>::NumOverflow)?;1828 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18291830 // update index collection1831 Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1832 } else {1833 let mut new_full_item = full_item.clone();1834 new_full_item.value -= value;18351836 // separate amount1837 if new_owner_account_id > 0 {1838 // new owner has account1839 let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1840 item.value += value;18411842 // update balance1843 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1844 .checked_add(value)1845 .ok_or(Error::<T>::NumOverflow)?;1846 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18471848 <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1849 } else {1850 // new owner do not have account1851 let item = FungibleItemType {1852 collection: collection_id,1853 owner: new_owner.clone(),1854 value1855 };18561857 Self::add_fungible_item(item)?;1858 }18591860 if amount == value {1861 Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;18621863 // remove approve list1864 <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1865 <FungibleItemList<T>>::remove(collection_id, item_id);1866 }18671868 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1869 }18701871 Ok(())1872 }18731874 fn transfer_refungible(1875 collection_id: CollectionId,1876 item_id: TokenId,1877 value: u128,1878 owner: T::AccountId,1879 new_owner: T::AccountId,1880 ) -> DispatchResult {1881 ensure!(1882 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1883 Error::<T>::TokenNotFound1884 );18851886 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1887 let item = full_item1888 .owner1889 .iter()1890 .filter(|i| i.owner == owner)1891 .next()1892 .ok_or(Error::<T>::NumOverflow)?;1893 let amount = item.fraction;18941895 ensure!(amount >= value, Error::<T>::TokenValueTooLow);18961897 // update balance1898 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1899 .checked_sub(value)1900 .ok_or(Error::<T>::NumOverflow)?;1901 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19021903 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1904 .checked_add(value)1905 .ok_or(Error::<T>::NumOverflow)?;1906 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);19071908 let old_owner = item.owner.clone();1909 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19101911 // transfer1912 if amount == value && !new_owner_has_account {1913 // change owner1914 // new owner do not have account1915 let mut new_full_item = full_item.clone();1916 new_full_item1917 .owner1918 .iter_mut()1919 .find(|i| i.owner == owner)1920 .unwrap()1921 .owner = new_owner.clone();1922 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);19231924 // update index collection1925 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1926 } else {1927 let mut new_full_item = full_item.clone();1928 new_full_item1929 .owner1930 .iter_mut()1931 .find(|i| i.owner == owner)1932 .unwrap()1933 .fraction -= value;19341935 // separate amount1936 if new_owner_has_account {1937 // new owner has account1938 new_full_item1939 .owner1940 .iter_mut()1941 .find(|i| i.owner == new_owner)1942 .unwrap()1943 .fraction += value;1944 } else {1945 // new owner do not have account1946 new_full_item.owner.push(Ownership {1947 owner: new_owner.clone(),1948 fraction: value,1949 });1950 Self::add_token_index(collection_id, item_id, new_owner.clone())?;1951 }19521953 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1954 }19551956 Ok(())1957 }19581959 fn transfer_nft(1960 collection_id: CollectionId,1961 item_id: TokenId,1962 sender: T::AccountId,1963 new_owner: T::AccountId,1964 ) -> DispatchResult {1965 ensure!(1966 <NftItemList<T>>::contains_key(collection_id, item_id),1967 Error::<T>::TokenNotFound1968 );19691970 let mut item = <NftItemList<T>>::get(collection_id, item_id);19711972 ensure!(1973 sender == item.owner,1974 Error::<T>::MustBeTokenOwner1975 );19761977 // update balance1978 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1979 .checked_sub(1)1980 .ok_or(Error::<T>::NumOverflow)?;1981 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);19821983 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1984 .checked_add(1)1985 .ok_or(Error::<T>::NumOverflow)?;1986 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);19871988 // change owner1989 let old_owner = item.owner.clone();1990 item.owner = new_owner.clone();1991 <NftItemList<T>>::insert(collection_id, item_id, item);19921993 // update index collection1994 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;19951996 // reset approved list1997 <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1998 Ok(())1999 }2000 2001 fn item_exists(2002 collection_id: CollectionId,2003 item_id: TokenId,2004 mode: &CollectionMode2005 ) -> DispatchResult {2006 match mode {2007 CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),2008 CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),2009 CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),2010 _ => ()2011 };2012 2013 Ok(())2014 }20152016 fn set_re_fungible_variable_data(2017 collection_id: CollectionId,2018 item_id: TokenId,2019 data: Vec<u8>2020 ) -> DispatchResult {2021 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);20222023 item.variable_data = data;20242025 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);20262027 Ok(())2028 }20292030 fn set_nft_variable_data(2031 collection_id: CollectionId,2032 item_id: TokenId,2033 data: Vec<u8>2034 ) -> DispatchResult {2035 let mut item = <NftItemList<T>>::get(collection_id, item_id);2036 2037 item.variable_data = data;20382039 <NftItemList<T>>::insert(collection_id, item_id, item);2040 2041 Ok(())2042 }20432044 fn init_collection(item: &CollectionType<T::AccountId>) {2045 // check params2046 assert!(2047 item.decimal_points <= MAX_DECIMAL_POINTS,2048 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2049 );2050 assert!(2051 item.name.len() <= 64,2052 "Collection name can not be longer than 63 char"2053 );2054 assert!(2055 item.name.len() <= 256,2056 "Collection description can not be longer than 255 char"2057 );2058 assert!(2059 item.token_prefix.len() <= 16,2060 "Token prefix can not be longer than 15 char"2061 );20622063 // Generate next collection ID2064 let next_id = CreatedCollectionCount::get()2065 .checked_add(1)2066 .unwrap();20672068 CreatedCollectionCount::put(next_id);2069 }20702071 fn init_nft_token(item: &NftItemType<T::AccountId>) {2072 let current_index = <ItemListIndex>::get(item.collection)2073 .checked_add(1)2074 .unwrap();20752076 let item_owner = item.owner.clone();2077 let collection_id = item.collection.clone();2078 Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();20792080 <ItemListIndex>::insert(collection_id, current_index);20812082 // Update balance2083 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2084 .checked_add(1)2085 .unwrap();2086 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2087 }20882089 fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {2090 let current_index = <ItemListIndex>::get(item.collection)2091 .checked_add(1)2092 .unwrap();2093 let owner = item.owner.clone();20942095 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();20962097 <ItemListIndex>::insert(item.collection, current_index);20982099 // Update balance2100 let new_balance = <Balance<T>>::get(item.collection, owner.clone())2101 .checked_add(item.value)2102 .unwrap();2103 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2104 }21052106 fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {2107 let current_index = <ItemListIndex>::get(item.collection)2108 .checked_add(1)2109 .unwrap();21102111 let value = item.owner.first().unwrap().fraction;2112 let owner = item.owner.first().unwrap().owner.clone();21132114 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();21152116 <ItemListIndex>::insert(item.collection, current_index);21172118 // Update balance2119 let new_balance = <Balance<T>>::get(item.collection, owner.clone())2120 .checked_add(value)2121 .unwrap();2122 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);2123 }21242125 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: T::AccountId) -> DispatchResult {21262127 // add to account limit2128 if <AccountItemCount<T>>::contains_key(owner.clone()) {21292130 // bound Owned tokens by a single address2131 let count = <AccountItemCount<T>>::get(owner.clone());2132 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);21332134 <AccountItemCount<T>>::insert(owner.clone(), count2135 .checked_add(1)2136 .ok_or(Error::<T>::NumOverflow)?);2137 }2138 else {2139 <AccountItemCount<T>>::insert(owner.clone(), 1);2140 }21412142 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2143 if list_exists {2144 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2145 let item_contains = list.contains(&item_index.clone());21462147 if !item_contains {2148 list.push(item_index.clone());2149 }21502151 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2152 } else {2153 let mut itm = Vec::new();2154 itm.push(item_index.clone());2155 <AddressTokens<T>>::insert(collection_id, owner, itm);2156 2157 }21582159 Ok(())2160 }21612162 fn remove_token_index(2163 collection_id: CollectionId,2164 item_index: TokenId,2165 owner: T::AccountId,2166 ) -> DispatchResult {21672168 // update counter2169 <AccountItemCount<T>>::insert(owner.clone(), 2170 <AccountItemCount<T>>::get(owner.clone())2171 .checked_sub(1)2172 .ok_or(Error::<T>::NumOverflow)?);217321742175 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2176 if list_exists {2177 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2178 let item_contains = list.contains(&item_index.clone());21792180 if item_contains {2181 list.retain(|&item| item != item_index);2182 <AddressTokens<T>>::insert(collection_id, owner, list);2183 }2184 }21852186 Ok(())2187 }21882189 fn move_token_index(2190 collection_id: CollectionId,2191 item_index: TokenId,2192 old_owner: T::AccountId,2193 new_owner: T::AccountId,2194 ) -> DispatchResult {2195 Self::remove_token_index(collection_id, item_index, old_owner)?;2196 Self::add_token_index(collection_id, item_index, new_owner)?;21972198 Ok(())2199 }2200}22012202////////////////////////////////////////////////////////////////////////////////////////////////////2203// Economic models2204// #region22052206/// Fee multiplier.2207pub type Multiplier = FixedU128;22082209type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2210 <T as system::Trait>::AccountId,2211>>::Balance;2212type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2213 <T as system::Trait>::AccountId,2214>>::NegativeImbalance;22152216/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2217/// in the queue.2218#[derive(Encode, Decode, Clone, Eq, PartialEq)]2219pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2220 #[codec(compact)] BalanceOf<T>2221);22222223impl<T: Trait + Send + Sync> sp_std::fmt::Debug2224 for ChargeTransactionPayment<T>2225{2226 #[cfg(feature = "std")]2227 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2228 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2229 }2230 #[cfg(not(feature = "std"))]2231 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2232 Ok(())2233 }2234}22352236impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2237where2238 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2239 BalanceOf<T>: Send + Sync + FixedPointOperand,2240{2241 /// utility constructor. Used only in client/factory code.2242 pub fn from(fee: BalanceOf<T>) -> Self {2243 Self(fee)2244 }22452246 pub fn traditional_fee(2247 len: usize,2248 info: &DispatchInfoOf<T::Call>,2249 tip: BalanceOf<T>,2250 ) -> BalanceOf<T>2251 where2252 T::Call: Dispatchable<Info = DispatchInfo>,2253 {2254 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2255 }22562257 fn withdraw_fee(2258 &self,2259 who: &T::AccountId,2260 call: &T::Call,2261 info: &DispatchInfoOf<T::Call>,2262 len: usize,2263 ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2264 let tip = self.0;22652266 // Set fee based on call type. Creating collection costs 1 Unique.2267 // All other transactions have traditional fees so far2268 // let fee = match call.is_sub_type() {2269 // Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2270 // _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2271 // // _ => <BalanceOf<T>>::from(100)2272 // };2273 let fee = Self::traditional_fee(len, info, tip);22742275 // Determine who is paying transaction fee based on ecnomic model2276 // Parse call to extract collection ID and access collection sponsor2277 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2278 Some(Call::create_item(collection_id, _owner, _properties)) => {22792280 // check free create limit2281 if <Collection<T>>::get(collection_id).limits.sponsored_data_size >= (_properties.len() as u32)2282 {2283 <Collection<T>>::get(collection_id).sponsor2284 } else {2285 T::AccountId::default()2286 }2287 }2288 Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2289 2290 let _collection_limits = <Collection<T>>::get(collection_id).limits;2291 let _collection_mode = <Collection<T>>::get(collection_id).mode;22922293 // sponsor timeout2294 let sponsor_transfer = match _collection_mode {2295 CollectionMode::NFT => {22962297 // get correct limit2298 let limit: u32 = if _collection_limits.sponsor_transfer_timeout > 0 {2299 _collection_limits.sponsor_transfer_timeout2300 } else {2301 ChainLimit::get().nft_sponsor_transfer_timeout2302 };23032304 let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2305 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2306 let limit_time = basket + limit.into();2307 if block_number >= limit_time {2308 <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2309 true2310 }2311 else {2312 false2313 }2314 }2315 CollectionMode::Fungible(_) => {23162317 // get correct limit2318 let limit: u32 = if _collection_limits.sponsor_transfer_timeout > 0 {2319 _collection_limits.sponsor_transfer_timeout2320 } else {2321 ChainLimit::get().fungible_sponsor_transfer_timeout2322 };23232324 let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2325 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2326 if basket.iter().any(|i| i.address == _new_owner.clone())2327 {2328 let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2329 let limit_time = item.start_block + limit.into();2330 if block_number >= limit_time {2331 basket.retain(|x| x.address == item.address);2332 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2333 <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2334 true2335 }2336 else {2337 false2338 }2339 }2340 else {2341 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2342 true2343 }2344 }2345 CollectionMode::ReFungible(_) => {23462347 // get correct limit2348 let limit: u32 = if _collection_limits.sponsor_transfer_timeout > 0 {2349 _collection_limits.sponsor_transfer_timeout2350 } else {2351 ChainLimit::get().refungible_sponsor_transfer_timeout2352 };23532354 let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2355 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2356 let limit_time = basket + limit.into();2357 if block_number >= limit_time {2358 <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2359 true2360 } else {2361 false2362 }2363 }2364 _ => {2365 false2366 },2367 };23682369 if !sponsor_transfer {2370 T::AccountId::default()2371 } else {2372 <Collection<T>>::get(collection_id).sponsor2373 }2374 }23752376 _ => T::AccountId::default(),2377 };23782379 // Sponsor smart contracts2380 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {23812382 // On instantiation: set the contract owner2383 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {23842385 let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2386 code_hash,2387 &data,2388 &who,2389 );2390 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());23912392 T::AccountId::default()2393 },23942395 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2396 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {23972398 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());23992400 let mut sponsor_transfer = false;2401 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2402 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2403 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2404 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2405 let limit_time = last_tx_block + rate_limit;24062407 if block_number >= limit_time {2408 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2409 sponsor_transfer = true;2410 }2411 } else {2412 sponsor_transfer = false;2413 }2414 2415 2416 let mut sp = T::AccountId::default();2417 if sponsor_transfer {2418 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2419 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2420 sp = called_contract;2421 }2422 }2423 }24242425 sp2426 },24272428 _ => sponsor,2429 };24302431 let mut who_pays_fee: T::AccountId = sponsor.clone();2432 if sponsor == T::AccountId::default() {2433 who_pays_fee = who.clone();2434 }24352436 // Only mess with balances if fee is not zero.2437 if fee.is_zero() {2438 return Ok((fee, None));2439 }24402441 match <T as transaction_payment::Trait>::Currency::withdraw(2442 &who_pays_fee,2443 fee,2444 if tip.is_zero() {2445 WithdrawReason::TransactionPayment.into()2446 } else {2447 WithdrawReason::TransactionPayment | WithdrawReason::Tip2448 },2449 ExistenceRequirement::KeepAlive,2450 ) {2451 Ok(imbalance) => Ok((fee, Some(imbalance))),2452 Err(_) => Err(InvalidTransaction::Payment.into()),2453 }2454 }2455}245624572458impl<T: Trait + Send + Sync> SignedExtension2459 for ChargeTransactionPayment<T>2460where2461 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2462 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2463{2464 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2465 type AccountId = T::AccountId;2466 type Call = T::Call;2467 type AdditionalSigned = ();2468 type Pre = (2469 BalanceOf<T>,2470 Self::AccountId,2471 Option<NegativeImbalanceOf<T>>,2472 BalanceOf<T>,2473 );2474 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2475 Ok(())2476 }24772478 fn validate(2479 &self,2480 _who: &Self::AccountId,2481 _call: &Self::Call,2482 _info: &DispatchInfoOf<Self::Call>,2483 _len: usize,2484 ) -> TransactionValidity {2485 Ok(ValidTransaction::default())2486 }24872488 fn pre_dispatch(2489 self,2490 who: &Self::AccountId,2491 call: &Self::Call,2492 info: &DispatchInfoOf<Self::Call>,2493 len: usize,2494 ) -> Result<Self::Pre, TransactionValidityError> {2495 let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2496 Ok((self.0, who.clone(), imbalance, fee))2497 }24982499 fn post_dispatch(2500 pre: Self::Pre,2501 info: &DispatchInfoOf<Self::Call>,2502 post_info: &PostDispatchInfoOf<Self::Call>,2503 len: usize,2504 _result: &DispatchResult,2505 ) -> Result<(), TransactionValidityError> {2506 let (tip, who, imbalance, fee) = pre;2507 if let Some(payed) = imbalance {2508 let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2509 len as u32, info, post_info, tip,2510 );2511 let refund = fee.saturating_sub(actual_fee);2512 let actual_payment =2513 match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2514 &who, refund,2515 ) {2516 Ok(refund_imbalance) => {2517 // The refund cannot be larger than the up front payed max weight.2518 // `PostDispatchInfo::calc_unspent` guards against such a case.2519 match payed.offset(refund_imbalance) {2520 Ok(actual_payment) => actual_payment,2521 Err(_) => return Err(InvalidTransaction::Payment.into()),2522 }2523 }2524 // We do not recreate the account using the refund. The up front payment2525 // is gone in that case.2526 Err(_) => payed,2527 };2528 let imbalances = actual_payment.split(tip);2529 <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2530 Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2531 );2532 }2533 Ok(())2534 }2535}25362537// #endregion