difftreelog
style fix variable name
in: master
1 file 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,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;437}438439#[cfg(feature = "runtime-benchmarks")]440mod benchmarking;441442// #endregion443444// # Used definitions445//446// ## User control levels447//448// chain-controlled - key is uncontrolled by user449// i.e autoincrementing index450// can use non-cryptographic hash451// real - key is controlled by user452// but it is hard to generate enough colliding values, i.e owner of signed txs453// can use non-cryptographic hash454// controlled - key is completly controlled by users455// i.e maps with mutable keys456// should use cryptographic hash457//458// ## User control level downgrade reasons459//460// ?1 - chain-controlled -> controlled461// collections/tokens can be destroyed, resulting in massive holes462// ?2 - chain-controlled -> controlled463// same as ?1, but can be only added, resulting in easier exploitation464// ?3 - real -> controlled465// no confirmation required, so addresses can be easily generated466decl_storage! {467 trait Store for Module<T: Config> as Nft {468469 //#region Private members470 /// Id of next collection471 CreatedCollectionCount: u32;472 /// Used for migrations473 ChainVersion: u64;474 /// Id of last collection token475 /// Collection id (controlled?1)476 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;477 //#endregion478479 //#region Chain limits struct480 pub ChainLimit get(fn chain_limit) config(): ChainLimits;481 //#endregion482483 //#region Bound counters484 /// Amount of collections destroyed, used for total amount tracking with485 /// CreatedCollectionCount486 DestroyedCollectionCount: u32;487 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)488 /// Account id (real)489 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;490 //#endregion491492 //#region Basic collections493 /// Collection info494 /// Collection id (controlled?1)495 pub Collection get(fn collection) config(): map hasher(blake2_128_concat) CollectionId => CollectionType<T::AccountId>;496 /// List of collection admins497 /// Collection id (controlled?2)498 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;499 /// Whitelisted collection users500 /// Collection id (controlled?2), user id (controlled?3)501 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;502 //#endregion503504 /// How many of collection items user have505 /// Collection id (controlled?2), account id (real)506 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;507508 /// Amount of items which spender can transfer out of owners account (via transferFrom)509 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))510 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;511512 //#region Item collections513 /// Collection id (controlled?2), token id (controlled?1)514 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;515 /// Collection id (controlled?2), owner (controlled?2)516 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;517 /// Collection id (controlled?2), token id (controlled?1)518 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;519 //#endregion520521 //#region Index list522 /// Collection id (controlled?2), tokens owner (controlled?2)523 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;524 //#endregion525526 //#region Tokens transfer rate limit baskets527 /// (Collection id (controlled?2), who created (real))528 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;529 /// Collection id (controlled?2), token id (controlled?2)530 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;531 /// Collection id (controlled?2), owning user (real)532 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;533 /// Collection id (controlled?2), token id (controlled?2)534 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;535 //#endregion536537 //#region Contract Sponsorship and Ownership538 /// Contract address (real)539 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;540 /// Contract address (real)541 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;542 /// (Contract address(real), caller (real))543 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;544 /// Contract address (real)545 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;546 /// Contract address (real)547 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 548 /// Contract address (real) => Whitelisted user (controlled?3)549 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 550 //#endregion551 }552 add_extra_genesis {553 build(|config: &GenesisConfig<T>| {554 // Modification of storage555 for (_num, _c) in &config.collection {556 <Module<T>>::init_collection(_c);557 }558559 for (_num, _c, _i) in &config.nft_item_id {560 <Module<T>>::init_nft_token(*_c, _i);561 }562563 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {564 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);565 }566567 for (_num, _c, _i) in &config.refungible_item_id {568 <Module<T>>::init_refungible_token(*_c, _i);569 }570 })571 }572}573574decl_event!(575 pub enum Event<T>576 where577 AccountId = <T as system::Config>::AccountId,578 {579 /// New collection was created580 /// 581 /// # Arguments582 /// 583 /// * collection_id: Globally unique identifier of newly created collection.584 /// 585 /// * mode: [CollectionMode] converted into u8.586 /// 587 /// * account_id: Collection owner.588 Created(CollectionId, u8, AccountId),589590 /// New item was created.591 /// 592 /// # Arguments593 /// 594 /// * collection_id: Id of the collection where item was created.595 /// 596 /// * item_id: Id of an item. Unique within the collection.597 ///598 /// * recipient: Owner of newly created item 599 ItemCreated(CollectionId, TokenId, AccountId),600601 /// Collection item was burned.602 /// 603 /// # Arguments604 /// 605 /// collection_id.606 /// 607 /// item_id: Identifier of burned NFT.608 ItemDestroyed(CollectionId, TokenId),609610 /// Item was transferred611 ///612 /// * collection_id: Id of collection to which item is belong613 ///614 /// * item_id: Id of an item615 ///616 /// * sender: Original owner of item617 ///618 /// * recipient: New owner of item619 ///620 /// * amount: Always 1 for NFT621 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),622 }623);624625decl_module! {626 pub struct Module<T: Config> for enum Call 627 where 628 origin: T::Origin629 {630 fn deposit_event() = default;631 type Error = Error<T>;632633 fn on_initialize(now: T::BlockNumber) -> Weight {634 0635 }636637 /// 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.638 /// 639 /// # Permissions640 /// 641 /// * Anyone.642 /// 643 /// # Arguments644 /// 645 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.646 /// 647 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.648 /// 649 /// * token_prefix: UTF-8 string with token prefix.650 /// 651 /// * mode: [CollectionMode] collection type and type dependent data.652 // returns collection ID653 #[weight = <T as Config>::WeightInfo::create_collection()]654 #[transactional]655 pub fn create_collection(origin,656 collection_name: Vec<u16>,657 collection_description: Vec<u16>,658 token_prefix: Vec<u8>,659 mode: CollectionMode) -> DispatchResult {660661 // Anyone can create a collection662 let who = ensure_signed(origin)?;663664 let decimal_points = match mode {665 CollectionMode::Fungible(points) => points,666 _ => 0667 };668669 let chain_limit = ChainLimit::get();670671 let created_count = CreatedCollectionCount::get();672 let destroyed_count = DestroyedCollectionCount::get();673674 // bound Total number of collections675 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);676677 // check params678 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);679 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);680 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);681 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);682683 // Generate next collection ID684 let next_id = created_count685 .checked_add(1)686 .ok_or(Error::<T>::NumOverflow)?;687688 CreatedCollectionCount::put(next_id);689690 let limits = CollectionLimits {691 sponsored_data_size: chain_limit.custom_data_limit,692 ..Default::default()693 };694695 // Create new collection696 let new_collection = CollectionType {697 owner: who.clone(),698 name: collection_name,699 mode: mode.clone(),700 mint_mode: false,701 access: AccessMode::Normal,702 description: collection_description,703 decimal_points: decimal_points,704 token_prefix: token_prefix,705 offchain_schema: Vec::new(),706 schema_version: SchemaVersion::ImageURL,707 sponsorship: SponsorshipState::Disabled,708 variable_on_chain_schema: Vec::new(),709 const_on_chain_schema: Vec::new(),710 limits,711 };712713 // Add new collection to map714 <Collection<T>>::insert(next_id, new_collection);715716 // call event717 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));718719 Ok(())720 }721722 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.723 /// 724 /// # Permissions725 /// 726 /// * Collection Owner.727 /// 728 /// # Arguments729 /// 730 /// * collection_id: collection to destroy.731 #[weight = <T as Config>::WeightInfo::destroy_collection()]732 #[transactional]733 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {734735 let sender = ensure_signed(origin)?;736 Self::check_owner_permissions(collection_id, sender)?;737738 let target_collection = <Collection<T>>::get(collection_id);739 if !target_collection.limits.owner_can_destroy {740 fail!(Error::<T>::NoPermission);741 }742743 <AddressTokens<T>>::remove_prefix(collection_id);744 <Allowances<T>>::remove_prefix(collection_id);745 <Balance<T>>::remove_prefix(collection_id);746 <ItemListIndex>::remove(collection_id);747 <AdminList<T>>::remove(collection_id);748 <Collection<T>>::remove(collection_id);749 <WhiteList<T>>::remove_prefix(collection_id);750751 <NftItemList<T>>::remove_prefix(collection_id);752 <FungibleItemList<T>>::remove_prefix(collection_id);753 <ReFungibleItemList<T>>::remove_prefix(collection_id);754755 <NftTransferBasket<T>>::remove_prefix(collection_id);756 <FungibleTransferBasket<T>>::remove_prefix(collection_id);757 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);758759 DestroyedCollectionCount::put(DestroyedCollectionCount::get()760 .checked_add(1)761 .ok_or(Error::<T>::NumOverflow)?);762763 Ok(())764 }765766 /// Add an address to white list.767 /// 768 /// # Permissions769 /// 770 /// * Collection Owner771 /// * Collection Admin772 /// 773 /// # Arguments774 /// 775 /// * collection_id.776 /// 777 /// * address.778 #[weight = <T as Config>::WeightInfo::add_to_white_list()]779 #[transactional]780 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{781782 let sender = ensure_signed(origin)?;783 Self::check_owner_or_admin_permissions(collection_id, sender)?;784785 <WhiteList<T>>::insert(collection_id, address, true);786 787 Ok(())788 }789790 /// Remove an address from white list.791 /// 792 /// # Permissions793 /// 794 /// * Collection Owner795 /// * Collection Admin796 /// 797 /// # Arguments798 /// 799 /// * collection_id.800 /// 801 /// * address.802 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]803 #[transactional]804 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{805806 let sender = ensure_signed(origin)?;807 Self::check_owner_or_admin_permissions(collection_id, sender)?;808809 <WhiteList<T>>::remove(collection_id, address);810811 Ok(())812 }813814 /// Toggle between normal and white list access for the methods with access for `Anyone`.815 /// 816 /// # Permissions817 /// 818 /// * Collection Owner.819 /// 820 /// # Arguments821 /// 822 /// * collection_id.823 /// 824 /// * mode: [AccessMode]825 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]826 #[transactional]827 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult828 {829 let sender = ensure_signed(origin)?;830831 Self::check_owner_permissions(collection_id, sender)?;832 let mut target_collection = <Collection<T>>::get(collection_id);833 target_collection.access = mode;834 <Collection<T>>::insert(collection_id, target_collection);835836 Ok(())837 }838839 /// Allows Anyone to create tokens if:840 /// * White List is enabled, and841 /// * Address is added to white list, and842 /// * This method was called with True parameter843 /// 844 /// # Permissions845 /// * Collection Owner846 ///847 /// # Arguments848 /// 849 /// * collection_id.850 /// 851 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.852 #[weight = <T as Config>::WeightInfo::set_mint_permission()]853 #[transactional]854 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult855 {856 let sender = ensure_signed(origin)?;857858 Self::check_owner_permissions(collection_id, sender)?;859 let mut target_collection = <Collection<T>>::get(collection_id);860 target_collection.mint_mode = mint_permission;861 <Collection<T>>::insert(collection_id, target_collection);862863 Ok(())864 }865866 /// Change the owner of the collection.867 /// 868 /// # Permissions869 /// 870 /// * Collection Owner.871 /// 872 /// # Arguments873 /// 874 /// * collection_id.875 /// 876 /// * new_owner.877 #[weight = <T as Config>::WeightInfo::change_collection_owner()]878 #[transactional]879 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {880881 let sender = ensure_signed(origin)?;882 Self::check_owner_permissions(collection_id, sender)?;883 let mut target_collection = <Collection<T>>::get(collection_id);884 target_collection.owner = new_owner;885 <Collection<T>>::insert(collection_id, target_collection);886887 Ok(())888 }889890 /// Adds an admin of the Collection.891 /// 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. 892 /// 893 /// # Permissions894 /// 895 /// * Collection Owner.896 /// * Collection Admin.897 /// 898 /// # Arguments899 /// 900 /// * collection_id: ID of the Collection to add admin for.901 /// 902 /// * new_admin_id: Address of new admin to add.903 #[weight = <T as Config>::WeightInfo::add_collection_admin()]904 #[transactional]905 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {906907 let sender = ensure_signed(origin)?;908 Self::check_owner_or_admin_permissions(collection_id, sender)?;909 let mut admin_arr: Vec<T::AccountId> = Vec::new();910911 if <AdminList<T>>::contains_key(collection_id)912 {913 admin_arr = <AdminList<T>>::get(collection_id);914 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);915 }916917 // Number of collection admins918 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);919920 admin_arr.push(new_admin_id);921 <AdminList<T>>::insert(collection_id, admin_arr);922923 Ok(())924 }925926 /// 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.927 ///928 /// # Permissions929 /// 930 /// * Collection Owner.931 /// * Collection Admin.932 /// 933 /// # Arguments934 /// 935 /// * collection_id: ID of the Collection to remove admin for.936 /// 937 /// * account_id: Address of admin to remove.938 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]939 #[transactional]940 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {941942 let sender = ensure_signed(origin)?;943 Self::check_owner_or_admin_permissions(collection_id, sender)?;944 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);945946 let mut admin_arr = <AdminList<T>>::get(collection_id);947 admin_arr.retain(|i| *i != account_id);948 <AdminList<T>>::insert(collection_id, admin_arr);949950 Ok(())951 }952953 /// # Permissions954 /// 955 /// * Collection Owner956 /// 957 /// # Arguments958 /// 959 /// * collection_id.960 /// 961 /// * new_sponsor.962 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]963 #[transactional]964 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {965966 let sender = ensure_signed(origin)?;967 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);968969 let mut target_collection = <Collection<T>>::get(collection_id);970 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);971972 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);973 <Collection<T>>::insert(collection_id, target_collection);974975 Ok(())976 }977978 /// # Permissions979 /// 980 /// * Sponsor.981 /// 982 /// # Arguments983 /// 984 /// * collection_id.985 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]986 #[transactional]987 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {988989 let sender = ensure_signed(origin)?;990 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);991992 let mut target_collection = <Collection<T>>::get(collection_id);993 ensure!(994 target_collection.sponsorship.pending_sponsor() == Some(&sender),995 Error::<T>::ConfirmUnsetSponsorFail996 );997998 target_collection.sponsorship = SponsorshipState::Confirmed(sender);999 <Collection<T>>::insert(collection_id, target_collection);10001001 Ok(())1002 }10031004 /// Switch back to pay-per-own-transaction model.1005 ///1006 /// # Permissions1007 ///1008 /// * Collection owner.1009 /// 1010 /// # Arguments1011 /// 1012 /// * collection_id.1013 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1014 #[transactional]1015 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10161017 let sender = ensure_signed(origin)?;1018 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10191020 let mut target_collection = <Collection<T>>::get(collection_id);1021 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10221023 target_collection.sponsorship = SponsorshipState::Disabled;1024 <Collection<T>>::insert(collection_id, target_collection);10251026 Ok(())1027 }10281029 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1030 /// 1031 /// # Permissions1032 /// 1033 /// * Collection Owner.1034 /// * Collection Admin.1035 /// * Anyone if1036 /// * White List is enabled, and1037 /// * Address is added to white list, and1038 /// * MintPermission is enabled (see SetMintPermission method)1039 /// 1040 /// # Arguments1041 /// 1042 /// * collection_id: ID of the collection.1043 /// 1044 /// * owner: Address, initial owner of the NFT.1045 ///1046 /// * data: Token data to store on chain.1047 // #[weight =1048 // (130_000_000 as Weight)1049 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1050 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1051 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]10521053 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1054 #[transactional]1055 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10561057 let sender = ensure_signed(origin)?;10581059 Self::collection_exists(collection_id)?;10601061 let target_collection = <Collection<T>>::get(collection_id);10621063 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1064 Self::validate_create_item_args(&target_collection, &data)?;1065 Self::create_item_no_validation(collection_id, owner, data)?;10661067 Ok(())1068 }10691070 /// This method creates multiple items in a collection created with CreateCollection method.1071 /// 1072 /// # Permissions1073 /// 1074 /// * Collection Owner.1075 /// * Collection Admin.1076 /// * Anyone if1077 /// * White List is enabled, and1078 /// * Address is added to white list, and1079 /// * MintPermission is enabled (see SetMintPermission method)1080 /// 1081 /// # Arguments1082 /// 1083 /// * collection_id: ID of the collection.1084 /// 1085 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1086 /// 1087 /// * owner: Address, initial owner of the NFT.1088 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1089 .map(|data| { data.len() })1090 .sum())]1091 #[transactional]1092 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {10931094 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1095 let sender = ensure_signed(origin)?;10961097 Self::collection_exists(collection_id)?;1098 let target_collection = <Collection<T>>::get(collection_id);10991100 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11011102 for data in &items_data {1103 Self::validate_create_item_args(&target_collection, data)?;1104 }1105 for data in &items_data {1106 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1107 }11081109 Ok(())1110 }11111112 /// Destroys a concrete instance of NFT.1113 /// 1114 /// # Permissions1115 /// 1116 /// * Collection Owner.1117 /// * Collection Admin.1118 /// * Current NFT Owner.1119 /// 1120 /// # Arguments1121 /// 1122 /// * collection_id: ID of the collection.1123 /// 1124 /// * item_id: ID of NFT to burn.1125 #[weight = <T as Config>::WeightInfo::burn_item()]1126 #[transactional]1127 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11281129 let sender = ensure_signed(origin)?;1130 Self::collection_exists(collection_id)?;11311132 // Transfer permissions check1133 let target_collection = <Collection<T>>::get(collection_id);1134 ensure!(1135 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1136 (1137 target_collection.limits.owner_can_transfer &&1138 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1139 ),1140 Error::<T>::NoPermission1141 );11421143 if target_collection.access == AccessMode::WhiteList {1144 Self::check_white_list(collection_id, &sender)?;1145 }11461147 match target_collection.mode1148 {1149 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1150 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1151 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1152 _ => ()1153 };11541155 // call event1156 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11571158 Ok(())1159 }11601161 /// Change ownership of the token.1162 /// 1163 /// # Permissions1164 /// 1165 /// * Collection Owner1166 /// * Collection Admin1167 /// * Current NFT owner1168 ///1169 /// # Arguments1170 /// 1171 /// * recipient: Address of token recipient.1172 /// 1173 /// * collection_id.1174 /// 1175 /// * item_id: ID of the item1176 /// * Non-Fungible Mode: Required.1177 /// * Fungible Mode: Ignored.1178 /// * Re-Fungible Mode: Required.1179 /// 1180 /// * value: Amount to transfer.1181 /// * Non-Fungible Mode: Ignored1182 /// * Fungible Mode: Must specify transferred amount1183 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1184 #[weight = <T as Config>::WeightInfo::transfer()]1185 #[transactional]1186 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1187 let sender = ensure_signed(origin)?;1188 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1189 }11901191 /// Set, change, or remove approved address to transfer the ownership of the NFT.1192 /// 1193 /// # Permissions1194 /// 1195 /// * Collection Owner1196 /// * Collection Admin1197 /// * Current NFT owner1198 /// 1199 /// # Arguments1200 /// 1201 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1202 /// 1203 /// * collection_id.1204 /// 1205 /// * item_id: ID of the item.1206 #[weight = <T as Config>::WeightInfo::approve()]1207 #[transactional]1208 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12091210 let sender = ensure_signed(origin)?;12111212 Self::collection_exists(collection_id)?;1213 Self::token_exists(collection_id, item_id, &sender)?;12141215 // Transfer permissions check1216 let target_collection = <Collection<T>>::get(collection_id);1217 let allowance_limit = if target_collection.limits.owner_can_transfer &&1218 Self::is_owner_or_admin_permissions(1219 collection_id,1220 sender.clone(),1221 ) {1222 None1223 } else if let Some(amount) = Self::owned_amount(1224 sender.clone(),1225 collection_id,1226 item_id,1227 ) {1228 Some(amount)1229 } else {1230 fail!(Error::<T>::NoPermission);1231 };12321233 if target_collection.access == AccessMode::WhiteList {1234 Self::check_white_list(collection_id, &sender)?;1235 Self::check_white_list(collection_id, &spender)?;1236 }12371238 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1239 let mut allowance: u128 = amount;1240 if allowance_exists {1241 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1242 }1243 if let Some(limit) = allowance_limit {1244 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1245 }1246 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12471248 Ok(())1249 }1250 1251 /// 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.1252 /// 1253 /// # Permissions1254 /// * Collection Owner1255 /// * Collection Admin1256 /// * Current NFT owner1257 /// * Address approved by current NFT owner1258 /// 1259 /// # Arguments1260 /// 1261 /// * from: Address that owns token.1262 /// 1263 /// * recipient: Address of token recipient.1264 /// 1265 /// * collection_id.1266 /// 1267 /// * item_id: ID of the item.1268 /// 1269 /// * value: Amount to transfer.1270 #[weight = <T as Config>::WeightInfo::transfer_from()]1271 #[transactional]1272 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12731274 let sender = ensure_signed(origin)?;1275 let mut appoved_transfer = false;12761277 // Check approval1278 let mut approval: u128 = 0;1279 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1280 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1281 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1282 appoved_transfer = true;1283 }12841285 let target_collection = <Collection<T>>::get(collection_id);12861287 // Limits check1288 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;12891290 // Transfer permissions check 1291 ensure!(1292 appoved_transfer || 1293 (1294 target_collection.limits.owner_can_transfer &&1295 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1296 ),1297 Error::<T>::NoPermission1298 );12991300 if target_collection.access == AccessMode::WhiteList {1301 Self::check_white_list(collection_id, &sender)?;1302 Self::check_white_list(collection_id, &recipient)?;1303 }13041305 // Reduce approval by transferred amount or remove if remaining approval drops to 01306 if approval.saturating_sub(value) > 0 {1307 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1308 }1309 else {1310 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1311 }13121313 match target_collection.mode1314 {1315 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1316 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1317 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1318 _ => ()1319 };13201321 Ok(())1322 }13231324 // #[weight = 0]1325 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13261327 // // let no_perm_mes = "You do not have permissions to modify this collection";1328 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1329 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1330 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13311332 // // // on_nft_received call13331334 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13351336 // Ok(())1337 // }13381339 /// Set off-chain data schema.1340 /// 1341 /// # Permissions1342 /// 1343 /// * Collection Owner1344 /// * Collection Admin1345 /// 1346 /// # Arguments1347 /// 1348 /// * collection_id.1349 /// 1350 /// * schema: String representing the offchain data schema.1351 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1352 #[transactional]1353 pub fn set_variable_meta_data (1354 origin,1355 collection_id: CollectionId,1356 item_id: TokenId,1357 data: Vec<u8>1358 ) -> DispatchResult {1359 let sender = ensure_signed(origin)?;1360 1361 Self::collection_exists(collection_id)?;1362 Self::token_exists(collection_id, item_id, &sender)?;13631364 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13651366 // Modify permissions check1367 let target_collection = <Collection<T>>::get(collection_id);1368 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1369 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1370 Error::<T>::NoPermission);13711372 match target_collection.mode1373 {1374 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1375 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1376 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1377 _ => fail!(Error::<T>::UnexpectedCollectionType)1378 };13791380 Ok(())1381 }1382 1383 /// Set schema standard1384 /// ImageURL1385 /// Unique1386 /// 1387 /// # Permissions1388 /// 1389 /// * Collection Owner1390 /// * Collection Admin1391 /// 1392 /// # Arguments1393 /// 1394 /// * collection_id.1395 /// 1396 /// * schema: SchemaVersion: enum1397 #[weight = <T as Config>::WeightInfo::set_schema_version()]1398 #[transactional]1399 pub fn set_schema_version(1400 origin,1401 collection_id: CollectionId,1402 version: SchemaVersion1403 ) -> DispatchResult {1404 let sender = ensure_signed(origin)?;1405 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1406 let mut target_collection = <Collection<T>>::get(collection_id);1407 target_collection.schema_version = version;1408 <Collection<T>>::insert(collection_id, target_collection);14091410 Ok(())1411 }14121413 /// Set off-chain data schema.1414 /// 1415 /// # Permissions1416 /// 1417 /// * Collection Owner1418 /// * Collection Admin1419 /// 1420 /// # Arguments1421 /// 1422 /// * collection_id.1423 /// 1424 /// * schema: String representing the offchain data schema.1425 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1426 #[transactional]1427 pub fn set_offchain_schema(1428 origin,1429 collection_id: CollectionId,1430 schema: Vec<u8>1431 ) -> DispatchResult {1432 let sender = ensure_signed(origin)?;1433 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14341435 // check schema limit1436 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14371438 let mut target_collection = <Collection<T>>::get(collection_id);1439 target_collection.offchain_schema = schema;1440 <Collection<T>>::insert(collection_id, target_collection);14411442 Ok(())1443 }14441445 /// Set const on-chain data schema.1446 /// 1447 /// # Permissions1448 /// 1449 /// * Collection Owner1450 /// * Collection Admin1451 /// 1452 /// # Arguments1453 /// 1454 /// * collection_id.1455 /// 1456 /// * schema: String representing the const on-chain data schema.1457 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1458 #[transactional]1459 pub fn set_const_on_chain_schema (1460 origin,1461 collection_id: CollectionId,1462 schema: Vec<u8>1463 ) -> DispatchResult {1464 let sender = ensure_signed(origin)?;1465 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14661467 // check schema limit1468 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14691470 let mut target_collection = <Collection<T>>::get(collection_id);1471 target_collection.const_on_chain_schema = schema;1472 <Collection<T>>::insert(collection_id, target_collection);14731474 Ok(())1475 }14761477 /// Set variable on-chain data schema.1478 /// 1479 /// # Permissions1480 /// 1481 /// * Collection Owner1482 /// * Collection Admin1483 /// 1484 /// # Arguments1485 /// 1486 /// * collection_id.1487 /// 1488 /// * schema: String representing the variable on-chain data schema.1489 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1490 #[transactional]1491 pub fn set_variable_on_chain_schema (1492 origin,1493 collection_id: CollectionId,1494 schema: Vec<u8>1495 ) -> DispatchResult {1496 let sender = ensure_signed(origin)?;1497 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14981499 // check schema limit1500 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15011502 let mut target_collection = <Collection<T>>::get(collection_id);1503 target_collection.variable_on_chain_schema = schema;1504 <Collection<T>>::insert(collection_id, target_collection);15051506 Ok(())1507 }15081509 // Sudo permissions function1510 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1511 #[transactional]1512 pub fn set_chain_limits(1513 origin,1514 limits: ChainLimits1515 ) -> DispatchResult {15161517 #[cfg(not(feature = "runtime-benchmarks"))]1518 ensure_root(origin)?;15191520 <ChainLimit>::put(limits);1521 Ok(())1522 }15231524 /// Enable smart contract self-sponsoring.1525 /// 1526 /// # Permissions1527 /// 1528 /// * Contract Owner1529 /// 1530 /// # Arguments1531 /// 1532 /// * contract address1533 /// * enable flag1534 /// 1535 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1536 #[transactional]1537 pub fn enable_contract_sponsoring(1538 origin,1539 contract_address: T::AccountId,1540 enable: bool1541 ) -> DispatchResult {15421543 let sender = ensure_signed(origin)?;15441545 #[cfg(feature = "runtime-benchmarks")]1546 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15471548 Self::ensure_contract_owned(sender, &contract_address)?;15491550 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1551 Ok(())1552 }15531554 /// Set the rate limit for contract sponsoring to specified number of blocks.1555 /// 1556 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1557 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1558 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1559 /// from contract endowment if there are at least B blocks between such transactions. 1560 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1561 /// 1562 /// # Permissions1563 /// 1564 /// * Contract Owner1565 /// 1566 /// # Arguments1567 /// 1568 /// -`contract_address`: Address of the contract to sponsor1569 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1570 /// 1571 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1572 #[transactional]1573 pub fn set_contract_sponsoring_rate_limit(1574 origin,1575 contract_address: T::AccountId,1576 rate_limit: T::BlockNumber1577 ) -> DispatchResult {1578 let sender = ensure_signed(origin)?;15791580 #[cfg(feature = "runtime-benchmarks")]1581 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15821583 Self::ensure_contract_owned(sender, &contract_address)?;1584 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1585 Ok(())1586 }15871588 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1589 /// 1590 /// # Permissions1591 /// 1592 /// * Address that deployed smart contract.1593 /// 1594 /// # Arguments1595 /// 1596 /// -`contract_address`: Address of the contract.1597 /// 1598 /// - `enable`: . 1599 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1600 #[transactional]1601 pub fn toggle_contract_white_list(1602 origin,1603 contract_address: T::AccountId,1604 enable: bool1605 ) -> DispatchResult {1606 let sender = ensure_signed(origin)?;16071608 #[cfg(feature = "runtime-benchmarks")]1609 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16101611 Self::ensure_contract_owned(sender, &contract_address)?;1612 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1613 Ok(())1614 }1615 1616 /// Add an address to smart contract white list.1617 /// 1618 /// # Permissions1619 /// 1620 /// * Address that deployed smart contract.1621 /// 1622 /// # Arguments1623 /// 1624 /// -`contract_address`: Address of the contract.1625 ///1626 /// -`account_address`: Address to add.1627 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1628 #[transactional]1629 pub fn add_to_contract_white_list(1630 origin,1631 contract_address: T::AccountId,1632 account_address: T::AccountId1633 ) -> DispatchResult {1634 let sender = ensure_signed(origin)?;16351636 #[cfg(feature = "runtime-benchmarks")]1637 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1638 1639 Self::ensure_contract_owned(sender, &contract_address)?; 1640 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1641 Ok(())1642 }16431644 /// Remove an address from smart contract white list.1645 /// 1646 /// # Permissions1647 /// 1648 /// * Address that deployed smart contract.1649 /// 1650 /// # Arguments1651 /// 1652 /// -`contract_address`: Address of the contract.1653 ///1654 /// -`account_address`: Address to remove.1655 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1656 #[transactional]1657 pub fn remove_from_contract_white_list(1658 origin,1659 contract_address: T::AccountId,1660 account_address: T::AccountId1661 ) -> DispatchResult {1662 let sender = ensure_signed(origin)?;16631664 #[cfg(feature = "runtime-benchmarks")]1665 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16661667 Self::ensure_contract_owned(sender, &contract_address)?;1668 <ContractWhiteList<T>>::remove(contract_address, account_address);1669 Ok(())1670 }16711672 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1673 #[transactional]1674 pub fn set_collection_limits(1675 origin,1676 collection_id: u32,1677 new_limits: CollectionLimits,1678 ) -> DispatchResult {1679 let sender = ensure_signed(origin)?;1680 Self::check_owner_permissions(collection_id, sender.clone())?;1681 let mut target_collection = <Collection<T>>::get(collection_id);1682 let old_limits = target_collection.limits;1683 let chain_limits = ChainLimit::get();16841685 // collection bounds1686 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1687 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1688 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1689 Error::<T>::CollectionLimitBoundsExceeded);16901691 // token_limit check prev1692 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1693 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16941695 ensure!(1696 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1697 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1698 Error::<T>::OwnerPermissionsCantBeReverted,1699 );17001701 target_collection.limits = new_limits;1702 <Collection<T>>::insert(collection_id, target_collection);17031704 Ok(())1705 } 1706 }1707}17081709impl<T: Config> Module<T> {17101711 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17121713 let target_collection = <Collection<T>>::get(collection_id);17141715 // Limits check1716 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17171718 // Transfer permissions check1719 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1720 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1721 Error::<T>::NoPermission);17221723 if target_collection.access == AccessMode::WhiteList {1724 Self::check_white_list(collection_id, &sender)?;1725 Self::check_white_list(collection_id, &recipient)?;1726 }17271728 match target_collection.mode1729 {1730 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1731 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1732 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1733 _ => ()1734 };17351736 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17371738 Ok(())1739 }174017411742 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17431744 // check token limit and account token limit1745 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1746 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1747 1748 Ok(())1749 }17501751 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17521753 // check token limit and account token limit1754 let total_items: u32 = ItemListIndex::get(collection_id);1755 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1756 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1757 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17581759 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1760 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1761 Self::check_white_list(collection_id, owner)?;1762 Self::check_white_list(collection_id, sender)?;1763 }17641765 Ok(())1766 }17671768 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1769 match target_collection.mode1770 {1771 CollectionMode::NFT => {1772 if let CreateItemData::NFT(data) = data {1773 // check sizes1774 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1775 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1776 } else {1777 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1778 }1779 },1780 CollectionMode::Fungible(_) => {1781 if let CreateItemData::Fungible(_) = data {1782 } else {1783 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1784 }1785 },1786 CollectionMode::ReFungible => {1787 if let CreateItemData::ReFungible(data) = data {17881789 // 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);17921793 // Check refungibility limits1794 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1795 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1796 } else {1797 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1798 }1799 },1800 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1801 };18021803 Ok(())1804 }18051806 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1807 match data1808 {1809 CreateItemData::NFT(data) => {1810 let item = NftItemType {1811 owner: owner.clone(),1812 const_data: data.const_data,1813 variable_data: data.variable_data1814 };18151816 Self::add_nft_item(collection_id, item)?;1817 },1818 CreateItemData::Fungible(data) => {1819 Self::add_fungible_item(collection_id, &owner, data.value)?;1820 },1821 CreateItemData::ReFungible(data) => {1822 let mut owner_list = Vec::new();1823 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18241825 let item = ReFungibleItemType {1826 owner: owner_list,1827 const_data: data.const_data,1828 variable_data: data.variable_data1829 };18301831 Self::add_refungible_item(collection_id, item)?;1832 }1833 };18341835 Ok(())1836 }18371838 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18391840 // Does new owner already have an account?1841 let mut balance: u128 = 0;1842 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1843 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1844 } 18451846 // Mint 1847 let item = FungibleItemType {1848 value: balance + value1849 };1850 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18511852 // Update balance1853 let new_balance = <Balance<T>>::get(collection_id, owner)1854 .checked_add(value)1855 .ok_or(Error::<T>::NumOverflow)?;1856 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18571858 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1859 Ok(())1860 }18611862 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1863 let current_index = <ItemListIndex>::get(collection_id)1864 .checked_add(1)1865 .ok_or(Error::<T>::NumOverflow)?;1866 let itemcopy = item.clone();18671868 ensure!(1869 item.owner.len() == 1,1870 Error::<T>::BadCreateRefungibleCall,1871 );1872 let item_owner = item.owner.first().expect("only one owner is defined");18731874 let value = item_owner.fraction;1875 let owner = item_owner.owner.clone();18761877 Self::add_token_index(collection_id, current_index, &owner)?;18781879 <ItemListIndex>::insert(collection_id, current_index);1880 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18811882 // Update balance1883 let new_balance = <Balance<T>>::get(collection_id, &owner)1884 .checked_add(value)1885 .ok_or(Error::<T>::NumOverflow)?;1886 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);18871888 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1889 Ok(())1890 }18911892 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1893 let current_index = <ItemListIndex>::get(collection_id)1894 .checked_add(1)1895 .ok_or(Error::<T>::NumOverflow)?;18961897 let item_owner = item.owner.clone();1898 Self::add_token_index(collection_id, current_index, &item.owner)?;18991900 <ItemListIndex>::insert(collection_id, current_index);1901 <NftItemList<T>>::insert(collection_id, current_index, item);19021903 // Update balance1904 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1905 .checked_add(1)1906 .ok_or(Error::<T>::NumOverflow)?;1907 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19081909 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1910 Ok(())1911 }19121913 fn burn_refungible_item(1914 collection_id: CollectionId,1915 item_id: TokenId,1916 owner: &T::AccountId,1917 ) -> DispatchResult {1918 ensure!(1919 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1920 Error::<T>::TokenNotFound1921 );1922 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1923 let rft_balance = token1924 .owner1925 .iter()1926 .find(|&i| i.owner == *owner)1927 .ok_or(Error::<T>::TokenNotFound)?;1928 Self::remove_token_index(collection_id, item_id, owner)?;19291930 // update balance1931 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1932 .checked_sub(rft_balance.fraction)1933 .ok_or(Error::<T>::NumOverflow)?;1934 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19351936 // Re-create owners list with sender removed1937 let index = token1938 .owner1939 .iter()1940 .position(|i| i.owner == *owner)1941 .expect("owned item is exists");1942 token.owner.remove(index);1943 let owner_count = token.owner.len();19441945 // Burn the token completely if this was the last (only) owner1946 if owner_count == 0 {1947 <ReFungibleItemList<T>>::remove(collection_id, item_id);1948 }1949 else {1950 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1951 }19521953 Ok(())1954 }19551956 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1957 ensure!(1958 <NftItemList<T>>::contains_key(collection_id, item_id),1959 Error::<T>::TokenNotFound1960 );1961 let item = <NftItemList<T>>::get(collection_id, item_id);1962 Self::remove_token_index(collection_id, item_id, &item.owner)?;19631964 // update balance1965 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1966 .checked_sub(1)1967 .ok_or(Error::<T>::NumOverflow)?;1968 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1969 <NftItemList<T>>::remove(collection_id, item_id);19701971 Ok(())1972 }19731974 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1975 ensure!(1976 <FungibleItemList<T>>::contains_key(collection_id, owner),1977 Error::<T>::TokenNotFound1978 );1979 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1980 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19811982 // update balance1983 let new_balance = <Balance<T>>::get(collection_id, owner)1984 .checked_sub(value)1985 .ok_or(Error::<T>::NumOverflow)?;1986 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19871988 if balance.value - value > 0 {1989 balance.value -= value;1990 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1991 }1992 else {1993 <FungibleItemList<T>>::remove(collection_id, owner);1994 }19951996 Ok(())1997 }19981999 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2000 ensure!(2001 <Collection<T>>::contains_key(collection_id),2002 Error::<T>::CollectionNotFound2003 );2004 Ok(())2005 }20062007 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2008 Self::collection_exists(collection_id)?;20092010 let target_collection = <Collection<T>>::get(collection_id);2011 ensure!(2012 subject == target_collection.owner,2013 Error::<T>::NoPermission2014 );20152016 Ok(())2017 }20182019 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2020 let target_collection = <Collection<T>>::get(collection_id);2021 let mut result: bool = subject == target_collection.owner;2022 let exists = <AdminList<T>>::contains_key(collection_id);20232024 if !result & exists {2025 if <AdminList<T>>::get(collection_id).contains(&subject) {2026 result = true2027 }2028 }20292030 result2031 }20322033 fn check_owner_or_admin_permissions(2034 collection_id: CollectionId,2035 subject: T::AccountId,2036 ) -> DispatchResult {2037 Self::collection_exists(collection_id)?;2038 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20392040 ensure!(2041 result,2042 Error::<T>::NoPermission2043 );2044 Ok(())2045 }20462047 fn owned_amount(2048 subject: T::AccountId,2049 collection_id: CollectionId,2050 item_id: TokenId,2051 ) -> Option<u128> {2052 let target_collection = <Collection<T>>::get(collection_id);20532054 match target_collection.mode {2055 CollectionMode::NFT => {2056 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2057 return Some(1)2058 }2059 None2060 },2061 CollectionMode::Fungible(_) => {2062 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2063 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2064 .value);2065 }2066 None2067 },2068 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2069 .owner2070 .iter()2071 .find(|i| i.owner == subject)2072 .map(|i| i.fraction),2073 CollectionMode::Invalid => None,2074 }2075 }20762077 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2078 let target_collection = <Collection<T>>::get(collection_id);20792080 match target_collection.mode {2081 CollectionMode::NFT => {2082 <NftItemList<T>>::get(collection_id, item_id).owner == subject2083 }2084 CollectionMode::Fungible(_) => {2085 <FungibleItemList<T>>::contains_key(collection_id, &subject)2086 }2087 CollectionMode::ReFungible => {2088 <ReFungibleItemList<T>>::get(collection_id, item_id)2089 .owner2090 .iter()2091 .any(|i| i.owner == subject)2092 }2093 CollectionMode::Invalid => false,2094 }2095 }20962097 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2098 let mes = Error::<T>::AddresNotInWhiteList;2099 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21002101 Ok(())2102 }21032104 /// Check if token exists. In case of Fungible, check if there is an entry for 2105 /// the owner in fungible balances double map2106 fn token_exists(2107 collection_id: CollectionId,2108 item_id: TokenId,2109 owner: &T::AccountId2110 ) -> DispatchResult {2111 let target_collection = <Collection<T>>::get(collection_id);2112 let exists = match target_collection.mode2113 {2114 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2115 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2116 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2117 _ => false2118 };21192120 ensure!(exists == true, Error::<T>::TokenNotFound);2121 Ok(())2122 }21232124 fn transfer_fungible(2125 collection_id: CollectionId,2126 value: u128,2127 owner: &T::AccountId,2128 recipient: &T::AccountId,2129 ) -> DispatchResult {2130 Self::token_exists(collection_id, 0, owner)?;21312132 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2133 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21342135 // Send balance to recipient (updates balanceOf of recipient)2136 Self::add_fungible_item(collection_id, recipient, value)?;21372138 // update balanceOf of sender2139 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21402141 // Reduce or remove sender2142 if balance.value == value {2143 <FungibleItemList<T>>::remove(collection_id, owner);2144 }2145 else {2146 balance.value -= value;2147 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2148 }21492150 Ok(())2151 }21522153 fn transfer_refungible(2154 collection_id: CollectionId,2155 item_id: TokenId,2156 value: u128,2157 owner: T::AccountId,2158 new_owner: T::AccountId,2159 ) -> DispatchResult {2160 Self::token_exists(collection_id, item_id, &owner)?;21612162 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2163 let item = full_item2164 .owner2165 .iter()2166 .filter(|i| i.owner == owner)2167 .next()2168 .ok_or(Error::<T>::TokenNotFound)?;2169 let amount = item.fraction;21702171 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21722173 // update balance2174 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2175 .checked_sub(value)2176 .ok_or(Error::<T>::NumOverflow)?;2177 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21782179 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2180 .checked_add(value)2181 .ok_or(Error::<T>::NumOverflow)?;2182 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);21832184 let old_owner = item.owner.clone();2185 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21862187 // transfer2188 if amount == value && !new_owner_has_account {2189 // change owner2190 // new owner do not have account2191 let mut new_full_item = full_item.clone();2192 new_full_item2193 .owner2194 .iter_mut()2195 .find(|i| i.owner == owner)2196 .expect("old owner does present in refungible")2197 .owner = new_owner.clone();2198 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21992200 // update index collection2201 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2202 } else {2203 let mut new_full_item = full_item.clone();2204 new_full_item2205 .owner2206 .iter_mut()2207 .find(|i| i.owner == owner)2208 .expect("old owner does present in refungible")2209 .fraction -= value;22102211 // separate amount2212 if new_owner_has_account {2213 // new owner has account2214 new_full_item2215 .owner2216 .iter_mut()2217 .find(|i| i.owner == new_owner)2218 .expect("new owner has account")2219 .fraction += value;2220 } else {2221 // new owner do not have account2222 new_full_item.owner.push(Ownership {2223 owner: new_owner.clone(),2224 fraction: value,2225 });2226 Self::add_token_index(collection_id, item_id, &new_owner)?;2227 }22282229 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2230 }22312232 Ok(())2233 }22342235 fn transfer_nft(2236 collection_id: CollectionId,2237 item_id: TokenId,2238 sender: T::AccountId,2239 new_owner: T::AccountId,2240 ) -> DispatchResult {2241 Self::token_exists(collection_id, item_id, &sender)?;22422243 let mut item = <NftItemList<T>>::get(collection_id, item_id);22442245 ensure!(2246 sender == item.owner,2247 Error::<T>::MustBeTokenOwner2248 );22492250 // update balance2251 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2252 .checked_sub(1)2253 .ok_or(Error::<T>::NumOverflow)?;2254 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22552256 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2257 .checked_add(1)2258 .ok_or(Error::<T>::NumOverflow)?;2259 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22602261 // change owner2262 let old_owner = item.owner.clone();2263 item.owner = new_owner.clone();2264 <NftItemList<T>>::insert(collection_id, item_id, item);22652266 // update index collection2267 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22682269 Ok(())2270 }2271 2272 fn set_re_fungible_variable_data(2273 collection_id: CollectionId,2274 item_id: TokenId,2275 data: Vec<u8>2276 ) -> DispatchResult {2277 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22782279 item.variable_data = data;22802281 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22822283 Ok(())2284 }22852286 fn set_nft_variable_data(2287 collection_id: CollectionId,2288 item_id: TokenId,2289 data: Vec<u8>2290 ) -> DispatchResult {2291 let mut item = <NftItemList<T>>::get(collection_id, item_id);2292 2293 item.variable_data = data;22942295 <NftItemList<T>>::insert(collection_id, item_id, item);2296 2297 Ok(())2298 }22992300 fn init_collection(item: &CollectionType<T::AccountId>) {2301 // check params2302 assert!(2303 item.decimal_points <= MAX_DECIMAL_POINTS,2304 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2305 );2306 assert!(2307 item.name.len() <= 64,2308 "Collection name can not be longer than 63 char"2309 );2310 assert!(2311 item.name.len() <= 256,2312 "Collection description can not be longer than 255 char"2313 );2314 assert!(2315 item.token_prefix.len() <= 16,2316 "Token prefix can not be longer than 15 char"2317 );23182319 // Generate next collection ID2320 let next_id = CreatedCollectionCount::get()2321 .checked_add(1)2322 .unwrap();23232324 CreatedCollectionCount::put(next_id);2325 }23262327 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2328 let current_index = <ItemListIndex>::get(collection_id)2329 .checked_add(1)2330 .unwrap();23312332 let item_owner = item.owner.clone();2333 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23342335 <ItemListIndex>::insert(collection_id, current_index);23362337 // Update balance2338 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2339 .checked_add(1)2340 .unwrap();2341 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2342 }23432344 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2345 let current_index = <ItemListIndex>::get(collection_id)2346 .checked_add(1)2347 .unwrap();23482349 Self::add_token_index(collection_id, current_index, owner).unwrap();23502351 <ItemListIndex>::insert(collection_id, current_index);23522353 // Update balance2354 let new_balance = <Balance<T>>::get(collection_id, owner)2355 .checked_add(item.value)2356 .unwrap();2357 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2358 }23592360 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2361 let current_index = <ItemListIndex>::get(collection_id)2362 .checked_add(1)2363 .unwrap();23642365 let value = item.owner.first().unwrap().fraction;2366 let owner = item.owner.first().unwrap().owner.clone();23672368 Self::add_token_index(collection_id, current_index, &owner).unwrap();23692370 <ItemListIndex>::insert(collection_id, current_index);23712372 // Update balance2373 let new_balance = <Balance<T>>::get(collection_id, &owner)2374 .checked_add(value)2375 .unwrap();2376 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2377 }23782379 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23802381 // add to account limit2382 if <AccountItemCount<T>>::contains_key(owner) {23832384 // bound Owned tokens by a single address2385 let count = <AccountItemCount<T>>::get(owner);2386 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);23872388 <AccountItemCount<T>>::insert(owner.clone(), count2389 .checked_add(1)2390 .ok_or(Error::<T>::NumOverflow)?);2391 }2392 else {2393 <AccountItemCount<T>>::insert(owner.clone(), 1);2394 }23952396 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2397 if list_exists {2398 let mut list = <AddressTokens<T>>::get(collection_id, owner);2399 let item_contains = list.contains(&item_index.clone());24002401 if !item_contains {2402 list.push(item_index.clone());2403 }24042405 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2406 } else {2407 let mut itm = Vec::new();2408 itm.push(item_index.clone());2409 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2410 }24112412 Ok(())2413 }24142415 fn remove_token_index(2416 collection_id: CollectionId,2417 item_index: TokenId,2418 owner: &T::AccountId,2419 ) -> DispatchResult {24202421 // update counter2422 <AccountItemCount<T>>::insert(owner.clone(), 2423 <AccountItemCount<T>>::get(owner)2424 .checked_sub(1)2425 .ok_or(Error::<T>::NumOverflow)?);242624272428 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2429 if list_exists {2430 let mut list = <AddressTokens<T>>::get(collection_id, owner);2431 let item_contains = list.contains(&item_index.clone());24322433 if item_contains {2434 list.retain(|&item| item != item_index);2435 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2436 }2437 }24382439 Ok(())2440 }24412442 fn move_token_index(2443 collection_id: CollectionId,2444 item_index: TokenId,2445 old_owner: &T::AccountId,2446 new_owner: &T::AccountId,2447 ) -> DispatchResult {2448 Self::remove_token_index(collection_id, item_index, old_owner)?;2449 Self::add_token_index(collection_id, item_index, new_owner)?;24502451 Ok(())2452 }2453 2454 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2455 if <ContractOwner<T>>::contains_key(contract.clone()) {2456 let owner = <ContractOwner<T>>::get(contract);2457 ensure!(account == owner, Error::<T>::NoPermission);2458 } else {2459 fail!(Error::<T>::NoPermission);2460 }24612462 Ok(())2463 }2464}24652466////////////////////////////////////////////////////////////////////////////////////////////////////2467// Economic models2468// #region24692470/// Fee multiplier.2471pub type Multiplier = FixedU128;24722473type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;24742475/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2476/// in the queue.2477#[derive(Encode, Decode, Clone, Eq, PartialEq)]2478pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24792480impl<T: Config + Send + Sync> sp_std::fmt::Debug 2481 for ChargeTransactionPayment<T>2482{2483 #[cfg(feature = "std")]2484 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2485 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2486 }2487 #[cfg(not(feature = "std"))]2488 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2489 Ok(())2490 }2491}24922493impl<T: Config> ChargeTransactionPayment<T>2494where2495 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2496 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2497 T::AccountId: AsRef<[u8]>,2498 T::AccountId: UncheckedFrom<T::Hash>,2499{2500 fn traditional_fee(2501 len: usize,2502 info: &DispatchInfoOf<T::Call>,2503 tip: BalanceOf<T>,2504 ) -> BalanceOf<T>2505 where2506 T::Call: Dispatchable<Info = DispatchInfo>,2507 {2508 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2509 }25102511 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2512 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2513 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2514 let len_saturation = max_block_length as u64 / (len as u64).max(1);2515 let coefficient: BalanceOf<T> = weight_saturation2516 .min(len_saturation)2517 .saturated_into::<BalanceOf<T>>();2518 final_fee2519 .saturating_mul(coefficient)2520 .saturated_into::<TransactionPriority>()2521 }25222523 fn withdraw_fee(2524 &self,2525 who: &T::AccountId,2526 call: &T::Call,2527 info: &DispatchInfoOf<T::Call>,2528 len: usize,2529 ) -> Result<2530 (2531 BalanceOf<T>,2532 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2533 ),2534 TransactionValidityError,2535 > {2536 let tip = self.0;25372538 // Set fee based on call type. Creating collection costs 1 Unique.2539 // All other transactions have traditional fees so far2540 // let fee = match call.is_sub_type() {2541 // Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2542 // _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2543 // // _ => <BalanceOf<T>>::from(100)2544 // };2545 let fee = Self::traditional_fee(len, info, tip);25462547 // Only mess with balances if fee is not zero.2548 if fee.is_zero() {2549 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2550 .map(|i| (fee, i));2551 }25522553 // Determine who is paying transaction fee based on ecnomic model2554 // Parse call to extract collection ID and access collection sponsor2555 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2556 Some(Call::create_item(collection_id, _owner, _properties)) => {25572558 // sponsor timeout2559 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25602561 let collection = <Collection<T>>::get(collection_id);25622563 let limit = collection.limits.sponsor_transfer_timeout;2564 let mut sponsored = true;2565 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2566 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2567 let limit_time = last_tx_block + limit.into();2568 if block_number <= limit_time {2569 sponsored = false;2570 }2571 }2572 if sponsored {2573 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2574 }25752576 // check free create limit2577 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2578 (sponsored)2579 {2580 collection.sponsorship.sponsor()2581 .cloned()2582 .unwrap_or_default()2583 } else {2584 T::AccountId::default()2585 }2586 }2587 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2588 2589 let mut sponsor_transfer = false;2590 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {25912592 let collection_limits = <Collection<T>>::get(collection_id).limits;2593 let collection_mode = <Collection<T>>::get(collection_id).mode;2594 2595 // sponsor timeout2596 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2597 sponsor_transfer = match collection_mode {2598 CollectionMode::NFT => {2599 2600 // get correct limit2601 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2602 collection_limits.sponsor_transfer_timeout2603 } else {2604 ChainLimit::get().nft_sponsor_transfer_timeout2605 };2606 2607 let mut sponsored = true;2608 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2609 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2610 let limit_time = last_tx_block + limit.into();2611 if block_number <= limit_time {2612 sponsored = false;2613 }2614 }2615 if sponsored {2616 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2617 }26182619 sponsored2620 }2621 CollectionMode::Fungible(_) => {2622 2623 // get correct limit2624 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2625 collection_limits.sponsor_transfer_timeout2626 } else {2627 ChainLimit::get().fungible_sponsor_transfer_timeout2628 };2629 2630 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2631 let mut sponsored = true;2632 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2633 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2634 let limit_time = last_tx_block + limit.into();2635 if block_number <= limit_time {2636 sponsored = false;2637 }2638 }2639 if sponsored {2640 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2641 }26422643 sponsored2644 }2645 CollectionMode::ReFungible => {2646 2647 // get correct limit2648 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2649 collection_limits.sponsor_transfer_timeout2650 } else {2651 ChainLimit::get().refungible_sponsor_transfer_timeout2652 };2653 2654 let mut sponsored = true;2655 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2656 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2657 let limit_time = last_tx_block + limit.into();2658 if block_number <= limit_time {2659 sponsored = false;2660 }2661 }2662 if sponsored {2663 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2664 }26652666 sponsored2667 }2668 _ => {2669 false2670 },2671 };2672 }26732674 if !sponsor_transfer {2675 T::AccountId::default()2676 } else {2677 <Collection<T>>::get(collection_id).sponsorship.sponsor()2678 .cloned()2679 .unwrap_or_default()2680 }2681 }26822683 _ => T::AccountId::default(),2684 };26852686 // Sponsor smart contracts2687 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26882689 // On instantiation: set the contract owner2690 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {26912692 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2693 &who,2694 code_hash,2695 salt,2696 );2697 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());26982699 T::AccountId::default()2700 },27012702 // On instantiation with code: set the contract owner2703 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27042705 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2706 &who,2707 &T::Hashing::hash(&_code),2708 _salt,2709 );27102711 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27122713 T::AccountId::default()2714 }27152716 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2717 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27182719 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27202721 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2722 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2723 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2724 2725 if !owned_contract && white_list_enabled {2726 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2727 return Err(InvalidTransaction::Call.into());2728 }2729 }27302731 let mut sponsor_transfer = false;2732 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2733 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2734 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2735 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2736 let limit_time = last_tx_block + rate_limit;27372738 if block_number >= limit_time {2739 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2740 sponsor_transfer = true;2741 }2742 } else {2743 sponsor_transfer = false;2744 }2745 2746 2747 let mut sp = T::AccountId::default();2748 if sponsor_transfer {2749 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2750 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2751 sp = called_contract;2752 }2753 }2754 }27552756 sp2757 },27582759 _ => sponsor,2760 };27612762 let mut who_pays_fee: T::AccountId = sponsor.clone();2763 if sponsor == T::AccountId::default() {2764 who_pays_fee = who.clone();2765 }27662767 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2768 .map(|i| (fee, i))2769 }2770}277127722773impl<T: Config + Send + Sync> SignedExtension2774 for ChargeTransactionPayment<T>2775where2776 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2777 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2778 T::AccountId: AsRef<[u8]>,2779 T::AccountId: UncheckedFrom<T::Hash>,2780{2781 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2782 type AccountId = T::AccountId;2783 type Call = T::Call;2784 type AdditionalSigned = ();2785 type Pre = (2786 // tip2787 BalanceOf<T>,2788 // who pays fee2789 Self::AccountId,2790 // imbalance resulting from withdrawing the fee2791 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2792 );2793 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2794 Ok(())2795 }27962797 fn validate(2798 &self,2799 who: &Self::AccountId,2800 call: &Self::Call,2801 info: &DispatchInfoOf<Self::Call>,2802 len: usize,2803 ) -> TransactionValidity {2804 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2805 Ok(ValidTransaction {2806 priority: Self::get_priority(len, info, fee),2807 ..Default::default()2808 })2809 }28102811 fn pre_dispatch(2812 self,2813 who: &Self::AccountId,2814 call: &Self::Call,2815 info: &DispatchInfoOf<Self::Call>,2816 len: usize,2817 ) -> Result<Self::Pre, TransactionValidityError> {2818 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2819 Ok((self.0, who.clone(), imbalance))2820 }28212822 fn post_dispatch(2823 pre: Self::Pre,2824 info: &DispatchInfoOf<Self::Call>,2825 post_info: &PostDispatchInfoOf<Self::Call>,2826 len: usize,2827 _result: &DispatchResult,2828 ) -> Result<(), TransactionValidityError> {2829 let (tip, who, imbalance) = pre;2830 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2831 len as u32,2832 info,2833 post_info,2834 tip,2835 );2836 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2837 Ok(())2838 }2839}28402841// #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,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;437}438439#[cfg(feature = "runtime-benchmarks")]440mod benchmarking;441442// #endregion443444// # Used definitions445//446// ## User control levels447//448// chain-controlled - key is uncontrolled by user449// i.e autoincrementing index450// can use non-cryptographic hash451// real - key is controlled by user452// but it is hard to generate enough colliding values, i.e owner of signed txs453// can use non-cryptographic hash454// controlled - key is completly controlled by users455// i.e maps with mutable keys456// should use cryptographic hash457//458// ## User control level downgrade reasons459//460// ?1 - chain-controlled -> controlled461// collections/tokens can be destroyed, resulting in massive holes462// ?2 - chain-controlled -> controlled463// same as ?1, but can be only added, resulting in easier exploitation464// ?3 - real -> controlled465// no confirmation required, so addresses can be easily generated466decl_storage! {467 trait Store for Module<T: Config> as Nft {468469 //#region Private members470 /// Id of next collection471 CreatedCollectionCount: u32;472 /// Used for migrations473 ChainVersion: u64;474 /// Id of last collection token475 /// Collection id (controlled?1)476 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;477 //#endregion478479 //#region Chain limits struct480 pub ChainLimit get(fn chain_limit) config(): ChainLimits;481 //#endregion482483 //#region Bound counters484 /// Amount of collections destroyed, used for total amount tracking with485 /// CreatedCollectionCount486 DestroyedCollectionCount: u32;487 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)488 /// Account id (real)489 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;490 //#endregion491492 //#region Basic collections493 /// Collection info494 /// Collection id (controlled?1)495 pub Collection get(fn collection) config(): map hasher(blake2_128_concat) CollectionId => CollectionType<T::AccountId>;496 /// List of collection admins497 /// Collection id (controlled?2)498 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;499 /// Whitelisted collection users500 /// Collection id (controlled?2), user id (controlled?3)501 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;502 //#endregion503504 /// How many of collection items user have505 /// Collection id (controlled?2), account id (real)506 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;507508 /// Amount of items which spender can transfer out of owners account (via transferFrom)509 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))510 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;511512 //#region Item collections513 /// Collection id (controlled?2), token id (controlled?1)514 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;515 /// Collection id (controlled?2), owner (controlled?2)516 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;517 /// Collection id (controlled?2), token id (controlled?1)518 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;519 //#endregion520521 //#region Index list522 /// Collection id (controlled?2), tokens owner (controlled?2)523 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;524 //#endregion525526 //#region Tokens transfer rate limit baskets527 /// (Collection id (controlled?2), who created (real))528 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;529 /// Collection id (controlled?2), token id (controlled?2)530 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;531 /// Collection id (controlled?2), owning user (real)532 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;533 /// Collection id (controlled?2), token id (controlled?2)534 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;535 //#endregion536537 //#region Contract Sponsorship and Ownership538 /// Contract address (real)539 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;540 /// Contract address (real)541 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;542 /// (Contract address(real), caller (real))543 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;544 /// Contract address (real)545 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;546 /// Contract address (real)547 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 548 /// Contract address (real) => Whitelisted user (controlled?3)549 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 550 //#endregion551 }552 add_extra_genesis {553 build(|config: &GenesisConfig<T>| {554 // Modification of storage555 for (_num, _c) in &config.collection {556 <Module<T>>::init_collection(_c);557 }558559 for (_num, _c, _i) in &config.nft_item_id {560 <Module<T>>::init_nft_token(*_c, _i);561 }562563 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {564 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);565 }566567 for (_num, _c, _i) in &config.refungible_item_id {568 <Module<T>>::init_refungible_token(*_c, _i);569 }570 })571 }572}573574decl_event!(575 pub enum Event<T>576 where577 AccountId = <T as system::Config>::AccountId,578 {579 /// New collection was created580 /// 581 /// # Arguments582 /// 583 /// * collection_id: Globally unique identifier of newly created collection.584 /// 585 /// * mode: [CollectionMode] converted into u8.586 /// 587 /// * account_id: Collection owner.588 Created(CollectionId, u8, AccountId),589590 /// New item was created.591 /// 592 /// # Arguments593 /// 594 /// * collection_id: Id of the collection where item was created.595 /// 596 /// * item_id: Id of an item. Unique within the collection.597 ///598 /// * recipient: Owner of newly created item 599 ItemCreated(CollectionId, TokenId, AccountId),600601 /// Collection item was burned.602 /// 603 /// # Arguments604 /// 605 /// collection_id.606 /// 607 /// item_id: Identifier of burned NFT.608 ItemDestroyed(CollectionId, TokenId),609610 /// Item was transferred611 ///612 /// * collection_id: Id of collection to which item is belong613 ///614 /// * item_id: Id of an item615 ///616 /// * sender: Original owner of item617 ///618 /// * recipient: New owner of item619 ///620 /// * amount: Always 1 for NFT621 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),622 }623);624625decl_module! {626 pub struct Module<T: Config> for enum Call 627 where 628 origin: T::Origin629 {630 fn deposit_event() = default;631 type Error = Error<T>;632633 fn on_initialize(now: T::BlockNumber) -> Weight {634 0635 }636637 /// 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.638 /// 639 /// # Permissions640 /// 641 /// * Anyone.642 /// 643 /// # Arguments644 /// 645 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.646 /// 647 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.648 /// 649 /// * token_prefix: UTF-8 string with token prefix.650 /// 651 /// * mode: [CollectionMode] collection type and type dependent data.652 // returns collection ID653 #[weight = <T as Config>::WeightInfo::create_collection()]654 #[transactional]655 pub fn create_collection(origin,656 collection_name: Vec<u16>,657 collection_description: Vec<u16>,658 token_prefix: Vec<u8>,659 mode: CollectionMode) -> DispatchResult {660661 // Anyone can create a collection662 let who = ensure_signed(origin)?;663664 let decimal_points = match mode {665 CollectionMode::Fungible(points) => points,666 _ => 0667 };668669 let chain_limit = ChainLimit::get();670671 let created_count = CreatedCollectionCount::get();672 let destroyed_count = DestroyedCollectionCount::get();673674 // bound Total number of collections675 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);676677 // check params678 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);679 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);680 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);681 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);682683 // Generate next collection ID684 let next_id = created_count685 .checked_add(1)686 .ok_or(Error::<T>::NumOverflow)?;687688 CreatedCollectionCount::put(next_id);689690 let limits = CollectionLimits {691 sponsored_data_size: chain_limit.custom_data_limit,692 ..Default::default()693 };694695 // Create new collection696 let new_collection = CollectionType {697 owner: who.clone(),698 name: collection_name,699 mode: mode.clone(),700 mint_mode: false,701 access: AccessMode::Normal,702 description: collection_description,703 decimal_points: decimal_points,704 token_prefix: token_prefix,705 offchain_schema: Vec::new(),706 schema_version: SchemaVersion::ImageURL,707 sponsorship: SponsorshipState::Disabled,708 variable_on_chain_schema: Vec::new(),709 const_on_chain_schema: Vec::new(),710 limits,711 };712713 // Add new collection to map714 <Collection<T>>::insert(next_id, new_collection);715716 // call event717 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));718719 Ok(())720 }721722 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.723 /// 724 /// # Permissions725 /// 726 /// * Collection Owner.727 /// 728 /// # Arguments729 /// 730 /// * collection_id: collection to destroy.731 #[weight = <T as Config>::WeightInfo::destroy_collection()]732 #[transactional]733 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {734735 let sender = ensure_signed(origin)?;736 Self::check_owner_permissions(collection_id, sender)?;737738 let target_collection = <Collection<T>>::get(collection_id);739 if !target_collection.limits.owner_can_destroy {740 fail!(Error::<T>::NoPermission);741 }742743 <AddressTokens<T>>::remove_prefix(collection_id);744 <Allowances<T>>::remove_prefix(collection_id);745 <Balance<T>>::remove_prefix(collection_id);746 <ItemListIndex>::remove(collection_id);747 <AdminList<T>>::remove(collection_id);748 <Collection<T>>::remove(collection_id);749 <WhiteList<T>>::remove_prefix(collection_id);750751 <NftItemList<T>>::remove_prefix(collection_id);752 <FungibleItemList<T>>::remove_prefix(collection_id);753 <ReFungibleItemList<T>>::remove_prefix(collection_id);754755 <NftTransferBasket<T>>::remove_prefix(collection_id);756 <FungibleTransferBasket<T>>::remove_prefix(collection_id);757 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);758759 DestroyedCollectionCount::put(DestroyedCollectionCount::get()760 .checked_add(1)761 .ok_or(Error::<T>::NumOverflow)?);762763 Ok(())764 }765766 /// Add an address to white list.767 /// 768 /// # Permissions769 /// 770 /// * Collection Owner771 /// * Collection Admin772 /// 773 /// # Arguments774 /// 775 /// * collection_id.776 /// 777 /// * address.778 #[weight = <T as Config>::WeightInfo::add_to_white_list()]779 #[transactional]780 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{781782 let sender = ensure_signed(origin)?;783 Self::check_owner_or_admin_permissions(collection_id, sender)?;784785 <WhiteList<T>>::insert(collection_id, address, true);786 787 Ok(())788 }789790 /// Remove an address from white list.791 /// 792 /// # Permissions793 /// 794 /// * Collection Owner795 /// * Collection Admin796 /// 797 /// # Arguments798 /// 799 /// * collection_id.800 /// 801 /// * address.802 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]803 #[transactional]804 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{805806 let sender = ensure_signed(origin)?;807 Self::check_owner_or_admin_permissions(collection_id, sender)?;808809 <WhiteList<T>>::remove(collection_id, address);810811 Ok(())812 }813814 /// Toggle between normal and white list access for the methods with access for `Anyone`.815 /// 816 /// # Permissions817 /// 818 /// * Collection Owner.819 /// 820 /// # Arguments821 /// 822 /// * collection_id.823 /// 824 /// * mode: [AccessMode]825 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]826 #[transactional]827 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult828 {829 let sender = ensure_signed(origin)?;830831 Self::check_owner_permissions(collection_id, sender)?;832 let mut target_collection = <Collection<T>>::get(collection_id);833 target_collection.access = mode;834 <Collection<T>>::insert(collection_id, target_collection);835836 Ok(())837 }838839 /// Allows Anyone to create tokens if:840 /// * White List is enabled, and841 /// * Address is added to white list, and842 /// * This method was called with True parameter843 /// 844 /// # Permissions845 /// * Collection Owner846 ///847 /// # Arguments848 /// 849 /// * collection_id.850 /// 851 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.852 #[weight = <T as Config>::WeightInfo::set_mint_permission()]853 #[transactional]854 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult855 {856 let sender = ensure_signed(origin)?;857858 Self::check_owner_permissions(collection_id, sender)?;859 let mut target_collection = <Collection<T>>::get(collection_id);860 target_collection.mint_mode = mint_permission;861 <Collection<T>>::insert(collection_id, target_collection);862863 Ok(())864 }865866 /// Change the owner of the collection.867 /// 868 /// # Permissions869 /// 870 /// * Collection Owner.871 /// 872 /// # Arguments873 /// 874 /// * collection_id.875 /// 876 /// * new_owner.877 #[weight = <T as Config>::WeightInfo::change_collection_owner()]878 #[transactional]879 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {880881 let sender = ensure_signed(origin)?;882 Self::check_owner_permissions(collection_id, sender)?;883 let mut target_collection = <Collection<T>>::get(collection_id);884 target_collection.owner = new_owner;885 <Collection<T>>::insert(collection_id, target_collection);886887 Ok(())888 }889890 /// Adds an admin of the Collection.891 /// 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. 892 /// 893 /// # Permissions894 /// 895 /// * Collection Owner.896 /// * Collection Admin.897 /// 898 /// # Arguments899 /// 900 /// * collection_id: ID of the Collection to add admin for.901 /// 902 /// * new_admin_id: Address of new admin to add.903 #[weight = <T as Config>::WeightInfo::add_collection_admin()]904 #[transactional]905 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {906907 let sender = ensure_signed(origin)?;908 Self::check_owner_or_admin_permissions(collection_id, sender)?;909 let mut admin_arr: Vec<T::AccountId> = Vec::new();910911 if <AdminList<T>>::contains_key(collection_id)912 {913 admin_arr = <AdminList<T>>::get(collection_id);914 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);915 }916917 // Number of collection admins918 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);919920 admin_arr.push(new_admin_id);921 <AdminList<T>>::insert(collection_id, admin_arr);922923 Ok(())924 }925926 /// 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.927 ///928 /// # Permissions929 /// 930 /// * Collection Owner.931 /// * Collection Admin.932 /// 933 /// # Arguments934 /// 935 /// * collection_id: ID of the Collection to remove admin for.936 /// 937 /// * account_id: Address of admin to remove.938 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]939 #[transactional]940 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {941942 let sender = ensure_signed(origin)?;943 Self::check_owner_or_admin_permissions(collection_id, sender)?;944 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);945946 let mut admin_arr = <AdminList<T>>::get(collection_id);947 admin_arr.retain(|i| *i != account_id);948 <AdminList<T>>::insert(collection_id, admin_arr);949950 Ok(())951 }952953 /// # Permissions954 /// 955 /// * Collection Owner956 /// 957 /// # Arguments958 /// 959 /// * collection_id.960 /// 961 /// * new_sponsor.962 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]963 #[transactional]964 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {965966 let sender = ensure_signed(origin)?;967 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);968969 let mut target_collection = <Collection<T>>::get(collection_id);970 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);971972 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);973 <Collection<T>>::insert(collection_id, target_collection);974975 Ok(())976 }977978 /// # Permissions979 /// 980 /// * Sponsor.981 /// 982 /// # Arguments983 /// 984 /// * collection_id.985 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]986 #[transactional]987 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {988989 let sender = ensure_signed(origin)?;990 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);991992 let mut target_collection = <Collection<T>>::get(collection_id);993 ensure!(994 target_collection.sponsorship.pending_sponsor() == Some(&sender),995 Error::<T>::ConfirmUnsetSponsorFail996 );997998 target_collection.sponsorship = SponsorshipState::Confirmed(sender);999 <Collection<T>>::insert(collection_id, target_collection);10001001 Ok(())1002 }10031004 /// Switch back to pay-per-own-transaction model.1005 ///1006 /// # Permissions1007 ///1008 /// * Collection owner.1009 /// 1010 /// # Arguments1011 /// 1012 /// * collection_id.1013 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1014 #[transactional]1015 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10161017 let sender = ensure_signed(origin)?;1018 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);10191020 let mut target_collection = <Collection<T>>::get(collection_id);1021 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);10221023 target_collection.sponsorship = SponsorshipState::Disabled;1024 <Collection<T>>::insert(collection_id, target_collection);10251026 Ok(())1027 }10281029 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1030 /// 1031 /// # Permissions1032 /// 1033 /// * Collection Owner.1034 /// * Collection Admin.1035 /// * Anyone if1036 /// * White List is enabled, and1037 /// * Address is added to white list, and1038 /// * MintPermission is enabled (see SetMintPermission method)1039 /// 1040 /// # Arguments1041 /// 1042 /// * collection_id: ID of the collection.1043 /// 1044 /// * owner: Address, initial owner of the NFT.1045 ///1046 /// * data: Token data to store on chain.1047 // #[weight =1048 // (130_000_000 as Weight)1049 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1050 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1051 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]10521053 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1054 #[transactional]1055 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {10561057 let sender = ensure_signed(origin)?;10581059 Self::collection_exists(collection_id)?;10601061 let target_collection = <Collection<T>>::get(collection_id);10621063 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;1064 Self::validate_create_item_args(&target_collection, &data)?;1065 Self::create_item_no_validation(collection_id, owner, data)?;10661067 Ok(())1068 }10691070 /// This method creates multiple items in a collection created with CreateCollection method.1071 /// 1072 /// # Permissions1073 /// 1074 /// * Collection Owner.1075 /// * Collection Admin.1076 /// * Anyone if1077 /// * White List is enabled, and1078 /// * Address is added to white list, and1079 /// * MintPermission is enabled (see SetMintPermission method)1080 /// 1081 /// # Arguments1082 /// 1083 /// * collection_id: ID of the collection.1084 /// 1085 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1086 /// 1087 /// * owner: Address, initial owner of the NFT.1088 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1089 .map(|data| { data.len() })1090 .sum())]1091 #[transactional]1092 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {10931094 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1095 let sender = ensure_signed(origin)?;10961097 Self::collection_exists(collection_id)?;1098 let target_collection = <Collection<T>>::get(collection_id);10991100 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;11011102 for data in &items_data {1103 Self::validate_create_item_args(&target_collection, data)?;1104 }1105 for data in &items_data {1106 Self::create_item_no_validation(collection_id, owner.clone(), data.clone())?;1107 }11081109 Ok(())1110 }11111112 /// Destroys a concrete instance of NFT.1113 /// 1114 /// # Permissions1115 /// 1116 /// * Collection Owner.1117 /// * Collection Admin.1118 /// * Current NFT Owner.1119 /// 1120 /// # Arguments1121 /// 1122 /// * collection_id: ID of the collection.1123 /// 1124 /// * item_id: ID of NFT to burn.1125 #[weight = <T as Config>::WeightInfo::burn_item()]1126 #[transactional]1127 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11281129 let sender = ensure_signed(origin)?;1130 Self::collection_exists(collection_id)?;11311132 // Transfer permissions check1133 let target_collection = <Collection<T>>::get(collection_id);1134 ensure!(1135 Self::is_item_owner(sender.clone(), collection_id, item_id) ||1136 (1137 target_collection.limits.owner_can_transfer &&1138 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1139 ),1140 Error::<T>::NoPermission1141 );11421143 if target_collection.access == AccessMode::WhiteList {1144 Self::check_white_list(collection_id, &sender)?;1145 }11461147 match target_collection.mode1148 {1149 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,1150 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, collection_id, value)?,1151 CollectionMode::ReFungible => Self::burn_refungible_item(collection_id, item_id, &sender)?,1152 _ => ()1153 };11541155 // call event1156 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));11571158 Ok(())1159 }11601161 /// Change ownership of the token.1162 /// 1163 /// # Permissions1164 /// 1165 /// * Collection Owner1166 /// * Collection Admin1167 /// * Current NFT owner1168 ///1169 /// # Arguments1170 /// 1171 /// * recipient: Address of token recipient.1172 /// 1173 /// * collection_id.1174 /// 1175 /// * item_id: ID of the item1176 /// * Non-Fungible Mode: Required.1177 /// * Fungible Mode: Ignored.1178 /// * Re-Fungible Mode: Required.1179 /// 1180 /// * value: Amount to transfer.1181 /// * Non-Fungible Mode: Ignored1182 /// * Fungible Mode: Must specify transferred amount1183 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1184 #[weight = <T as Config>::WeightInfo::transfer()]1185 #[transactional]1186 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1187 let sender = ensure_signed(origin)?;1188 Self::transfer_internal(sender, recipient, collection_id, item_id, value)1189 }11901191 /// Set, change, or remove approved address to transfer the ownership of the NFT.1192 /// 1193 /// # Permissions1194 /// 1195 /// * Collection Owner1196 /// * Collection Admin1197 /// * Current NFT owner1198 /// 1199 /// # Arguments1200 /// 1201 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1202 /// 1203 /// * collection_id.1204 /// 1205 /// * item_id: ID of the item.1206 #[weight = <T as Config>::WeightInfo::approve()]1207 #[transactional]1208 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12091210 let sender = ensure_signed(origin)?;12111212 Self::collection_exists(collection_id)?;1213 Self::token_exists(collection_id, item_id, &sender)?;12141215 // Transfer permissions check1216 let target_collection = <Collection<T>>::get(collection_id);1217 let allowance_limit = if target_collection.limits.owner_can_transfer &&1218 Self::is_owner_or_admin_permissions(1219 collection_id,1220 sender.clone(),1221 ) {1222 None1223 } else if let Some(amount) = Self::owned_amount(1224 sender.clone(),1225 collection_id,1226 item_id,1227 ) {1228 Some(amount)1229 } else {1230 fail!(Error::<T>::NoPermission);1231 };12321233 if target_collection.access == AccessMode::WhiteList {1234 Self::check_white_list(collection_id, &sender)?;1235 Self::check_white_list(collection_id, &spender)?;1236 }12371238 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1239 let mut allowance: u128 = amount;1240 if allowance_exists {1241 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1242 }1243 if let Some(limit) = allowance_limit {1244 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1245 }1246 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12471248 Ok(())1249 }1250 1251 /// 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.1252 /// 1253 /// # Permissions1254 /// * Collection Owner1255 /// * Collection Admin1256 /// * Current NFT owner1257 /// * Address approved by current NFT owner1258 /// 1259 /// # Arguments1260 /// 1261 /// * from: Address that owns token.1262 /// 1263 /// * recipient: Address of token recipient.1264 /// 1265 /// * collection_id.1266 /// 1267 /// * item_id: ID of the item.1268 /// 1269 /// * value: Amount to transfer.1270 #[weight = <T as Config>::WeightInfo::transfer_from()]1271 #[transactional]1272 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12731274 let sender = ensure_signed(origin)?;1275 let mut appoved_transfer = false;12761277 // Check approval1278 let mut approval: u128 = 0;1279 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1280 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1281 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1282 appoved_transfer = true;1283 }12841285 let target_collection = <Collection<T>>::get(collection_id);12861287 // Limits check1288 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;12891290 // Transfer permissions check 1291 ensure!(1292 appoved_transfer || 1293 (1294 target_collection.limits.owner_can_transfer &&1295 Self::is_owner_or_admin_permissions(collection_id, sender.clone())1296 ),1297 Error::<T>::NoPermission1298 );12991300 if target_collection.access == AccessMode::WhiteList {1301 Self::check_white_list(collection_id, &sender)?;1302 Self::check_white_list(collection_id, &recipient)?;1303 }13041305 // Reduce approval by transferred amount or remove if remaining approval drops to 01306 if approval.saturating_sub(value) > 0 {1307 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1308 }1309 else {1310 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1311 }13121313 match target_collection.mode1314 {1315 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1316 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &from, &recipient)?,1317 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1318 _ => ()1319 };13201321 Ok(())1322 }13231324 // #[weight = 0]1325 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13261327 // // let no_perm_mes = "You do not have permissions to modify this collection";1328 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1329 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1330 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13311332 // // // on_nft_received call13331334 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13351336 // Ok(())1337 // }13381339 /// Set off-chain data schema.1340 /// 1341 /// # Permissions1342 /// 1343 /// * Collection Owner1344 /// * Collection Admin1345 /// 1346 /// # Arguments1347 /// 1348 /// * collection_id.1349 /// 1350 /// * schema: String representing the offchain data schema.1351 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1352 #[transactional]1353 pub fn set_variable_meta_data (1354 origin,1355 collection_id: CollectionId,1356 item_id: TokenId,1357 data: Vec<u8>1358 ) -> DispatchResult {1359 let sender = ensure_signed(origin)?;1360 1361 Self::collection_exists(collection_id)?;1362 Self::token_exists(collection_id, item_id, &sender)?;13631364 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13651366 // Modify permissions check1367 let target_collection = <Collection<T>>::get(collection_id);1368 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1369 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1370 Error::<T>::NoPermission);13711372 match target_collection.mode1373 {1374 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1375 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1376 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1377 _ => fail!(Error::<T>::UnexpectedCollectionType)1378 };13791380 Ok(())1381 }1382 1383 /// Set schema standard1384 /// ImageURL1385 /// Unique1386 /// 1387 /// # Permissions1388 /// 1389 /// * Collection Owner1390 /// * Collection Admin1391 /// 1392 /// # Arguments1393 /// 1394 /// * collection_id.1395 /// 1396 /// * schema: SchemaVersion: enum1397 #[weight = <T as Config>::WeightInfo::set_schema_version()]1398 #[transactional]1399 pub fn set_schema_version(1400 origin,1401 collection_id: CollectionId,1402 version: SchemaVersion1403 ) -> DispatchResult {1404 let sender = ensure_signed(origin)?;1405 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;1406 let mut target_collection = <Collection<T>>::get(collection_id);1407 target_collection.schema_version = version;1408 <Collection<T>>::insert(collection_id, target_collection);14091410 Ok(())1411 }14121413 /// Set off-chain data schema.1414 /// 1415 /// # Permissions1416 /// 1417 /// * Collection Owner1418 /// * Collection Admin1419 /// 1420 /// # Arguments1421 /// 1422 /// * collection_id.1423 /// 1424 /// * schema: String representing the offchain data schema.1425 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1426 #[transactional]1427 pub fn set_offchain_schema(1428 origin,1429 collection_id: CollectionId,1430 schema: Vec<u8>1431 ) -> DispatchResult {1432 let sender = ensure_signed(origin)?;1433 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14341435 // check schema limit1436 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14371438 let mut target_collection = <Collection<T>>::get(collection_id);1439 target_collection.offchain_schema = schema;1440 <Collection<T>>::insert(collection_id, target_collection);14411442 Ok(())1443 }14441445 /// Set const on-chain data schema.1446 /// 1447 /// # Permissions1448 /// 1449 /// * Collection Owner1450 /// * Collection Admin1451 /// 1452 /// # Arguments1453 /// 1454 /// * collection_id.1455 /// 1456 /// * schema: String representing the const on-chain data schema.1457 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1458 #[transactional]1459 pub fn set_const_on_chain_schema (1460 origin,1461 collection_id: CollectionId,1462 schema: Vec<u8>1463 ) -> DispatchResult {1464 let sender = ensure_signed(origin)?;1465 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14661467 // check schema limit1468 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14691470 let mut target_collection = <Collection<T>>::get(collection_id);1471 target_collection.const_on_chain_schema = schema;1472 <Collection<T>>::insert(collection_id, target_collection);14731474 Ok(())1475 }14761477 /// Set variable on-chain data schema.1478 /// 1479 /// # Permissions1480 /// 1481 /// * Collection Owner1482 /// * Collection Admin1483 /// 1484 /// # Arguments1485 /// 1486 /// * collection_id.1487 /// 1488 /// * schema: String representing the variable on-chain data schema.1489 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1490 #[transactional]1491 pub fn set_variable_on_chain_schema (1492 origin,1493 collection_id: CollectionId,1494 schema: Vec<u8>1495 ) -> DispatchResult {1496 let sender = ensure_signed(origin)?;1497 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;14981499 // check schema limit1500 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15011502 let mut target_collection = <Collection<T>>::get(collection_id);1503 target_collection.variable_on_chain_schema = schema;1504 <Collection<T>>::insert(collection_id, target_collection);15051506 Ok(())1507 }15081509 // Sudo permissions function1510 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1511 #[transactional]1512 pub fn set_chain_limits(1513 origin,1514 limits: ChainLimits1515 ) -> DispatchResult {15161517 #[cfg(not(feature = "runtime-benchmarks"))]1518 ensure_root(origin)?;15191520 <ChainLimit>::put(limits);1521 Ok(())1522 }15231524 /// Enable smart contract self-sponsoring.1525 /// 1526 /// # Permissions1527 /// 1528 /// * Contract Owner1529 /// 1530 /// # Arguments1531 /// 1532 /// * contract address1533 /// * enable flag1534 /// 1535 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1536 #[transactional]1537 pub fn enable_contract_sponsoring(1538 origin,1539 contract_address: T::AccountId,1540 enable: bool1541 ) -> DispatchResult {15421543 let sender = ensure_signed(origin)?;15441545 #[cfg(feature = "runtime-benchmarks")]1546 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15471548 Self::ensure_contract_owned(sender, &contract_address)?;15491550 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1551 Ok(())1552 }15531554 /// Set the rate limit for contract sponsoring to specified number of blocks.1555 /// 1556 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1557 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1558 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1559 /// from contract endowment if there are at least B blocks between such transactions. 1560 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1561 /// 1562 /// # Permissions1563 /// 1564 /// * Contract Owner1565 /// 1566 /// # Arguments1567 /// 1568 /// -`contract_address`: Address of the contract to sponsor1569 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1570 /// 1571 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1572 #[transactional]1573 pub fn set_contract_sponsoring_rate_limit(1574 origin,1575 contract_address: T::AccountId,1576 rate_limit: T::BlockNumber1577 ) -> DispatchResult {1578 let sender = ensure_signed(origin)?;15791580 #[cfg(feature = "runtime-benchmarks")]1581 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15821583 Self::ensure_contract_owned(sender, &contract_address)?;1584 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1585 Ok(())1586 }15871588 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1589 /// 1590 /// # Permissions1591 /// 1592 /// * Address that deployed smart contract.1593 /// 1594 /// # Arguments1595 /// 1596 /// -`contract_address`: Address of the contract.1597 /// 1598 /// - `enable`: . 1599 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1600 #[transactional]1601 pub fn toggle_contract_white_list(1602 origin,1603 contract_address: T::AccountId,1604 enable: bool1605 ) -> DispatchResult {1606 let sender = ensure_signed(origin)?;16071608 #[cfg(feature = "runtime-benchmarks")]1609 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16101611 Self::ensure_contract_owned(sender, &contract_address)?;1612 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1613 Ok(())1614 }1615 1616 /// Add an address to smart contract white list.1617 /// 1618 /// # Permissions1619 /// 1620 /// * Address that deployed smart contract.1621 /// 1622 /// # Arguments1623 /// 1624 /// -`contract_address`: Address of the contract.1625 ///1626 /// -`account_address`: Address to add.1627 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1628 #[transactional]1629 pub fn add_to_contract_white_list(1630 origin,1631 contract_address: T::AccountId,1632 account_address: T::AccountId1633 ) -> DispatchResult {1634 let sender = ensure_signed(origin)?;16351636 #[cfg(feature = "runtime-benchmarks")]1637 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1638 1639 Self::ensure_contract_owned(sender, &contract_address)?; 1640 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1641 Ok(())1642 }16431644 /// Remove an address from smart contract white list.1645 /// 1646 /// # Permissions1647 /// 1648 /// * Address that deployed smart contract.1649 /// 1650 /// # Arguments1651 /// 1652 /// -`contract_address`: Address of the contract.1653 ///1654 /// -`account_address`: Address to remove.1655 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1656 #[transactional]1657 pub fn remove_from_contract_white_list(1658 origin,1659 contract_address: T::AccountId,1660 account_address: T::AccountId1661 ) -> DispatchResult {1662 let sender = ensure_signed(origin)?;16631664 #[cfg(feature = "runtime-benchmarks")]1665 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16661667 Self::ensure_contract_owned(sender, &contract_address)?;1668 <ContractWhiteList<T>>::remove(contract_address, account_address);1669 Ok(())1670 }16711672 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1673 #[transactional]1674 pub fn set_collection_limits(1675 origin,1676 collection_id: u32,1677 new_limits: CollectionLimits,1678 ) -> DispatchResult {1679 let sender = ensure_signed(origin)?;1680 Self::check_owner_permissions(collection_id, sender.clone())?;1681 let mut target_collection = <Collection<T>>::get(collection_id);1682 let old_limits = target_collection.limits;1683 let chain_limits = ChainLimit::get();16841685 // collection bounds1686 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1687 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1688 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1689 Error::<T>::CollectionLimitBoundsExceeded);16901691 // token_limit check prev1692 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1693 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16941695 ensure!(1696 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1697 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1698 Error::<T>::OwnerPermissionsCantBeReverted,1699 );17001701 target_collection.limits = new_limits;1702 <Collection<T>>::insert(collection_id, target_collection);17031704 Ok(())1705 } 1706 }1707}17081709impl<T: Config> Module<T> {17101711 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {17121713 let target_collection = <Collection<T>>::get(collection_id);17141715 // Limits check1716 Self::is_correct_transfer(collection_id, &target_collection, &recipient)?;17171718 // Transfer permissions check1719 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1720 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1721 Error::<T>::NoPermission);17221723 if target_collection.access == AccessMode::WhiteList {1724 Self::check_white_list(collection_id, &sender)?;1725 Self::check_white_list(collection_id, &recipient)?;1726 }17271728 match target_collection.mode1729 {1730 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient.clone())?,1731 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, value, &sender, &recipient)?,1732 CollectionMode::ReFungible => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient.clone())?,1733 _ => ()1734 };17351736 Self::deposit_event(RawEvent::Transfer(collection_id, item_id, sender, recipient, value));17371738 Ok(())1739 }174017411742 fn is_correct_transfer(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, recipient: &T::AccountId) -> DispatchResult {17431744 // check token limit and account token limit1745 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1746 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1747 1748 Ok(())1749 }17501751 fn can_create_items_in_collection(collection_id: CollectionId, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {17521753 // check token limit and account token limit1754 let total_items: u32 = ItemListIndex::get(collection_id);1755 let account_items: u32 = <AddressTokens<T>>::get(collection_id, owner).len() as u32;1756 ensure!(collection.limits.token_limit > total_items, Error::<T>::CollectionTokenLimitExceeded);1757 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);17581759 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1760 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1761 Self::check_white_list(collection_id, owner)?;1762 Self::check_white_list(collection_id, sender)?;1763 }17641765 Ok(())1766 }17671768 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1769 match target_collection.mode1770 {1771 CollectionMode::NFT => {1772 if let CreateItemData::NFT(data) = data {1773 // check sizes1774 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1775 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1776 } else {1777 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1778 }1779 },1780 CollectionMode::Fungible(_) => {1781 if let CreateItemData::Fungible(_) = data {1782 } else {1783 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1784 }1785 },1786 CollectionMode::ReFungible => {1787 if let CreateItemData::ReFungible(data) = data {17881789 // 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);17921793 // Check refungibility limits1794 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1795 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1796 } else {1797 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1798 }1799 },1800 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1801 };18021803 Ok(())1804 }18051806 fn create_item_no_validation(collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1807 match data1808 {1809 CreateItemData::NFT(data) => {1810 let item = NftItemType {1811 owner: owner.clone(),1812 const_data: data.const_data,1813 variable_data: data.variable_data1814 };18151816 Self::add_nft_item(collection_id, item)?;1817 },1818 CreateItemData::Fungible(data) => {1819 Self::add_fungible_item(collection_id, &owner, data.value)?;1820 },1821 CreateItemData::ReFungible(data) => {1822 let mut owner_list = Vec::new();1823 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18241825 let item = ReFungibleItemType {1826 owner: owner_list,1827 const_data: data.const_data,1828 variable_data: data.variable_data1829 };18301831 Self::add_refungible_item(collection_id, item)?;1832 }1833 };18341835 Ok(())1836 }18371838 fn add_fungible_item(collection_id: CollectionId, owner: &T::AccountId, value: u128) -> DispatchResult {18391840 // Does new owner already have an account?1841 let mut balance: u128 = 0;1842 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1843 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1844 } 18451846 // Mint 1847 let item = FungibleItemType {1848 value: balance + value1849 };1850 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);18511852 // Update balance1853 let new_balance = <Balance<T>>::get(collection_id, owner)1854 .checked_add(value)1855 .ok_or(Error::<T>::NumOverflow)?;1856 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);18571858 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1859 Ok(())1860 }18611862 fn add_refungible_item(collection_id: CollectionId, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1863 let current_index = <ItemListIndex>::get(collection_id)1864 .checked_add(1)1865 .ok_or(Error::<T>::NumOverflow)?;1866 let itemcopy = item.clone();18671868 ensure!(1869 item.owner.len() == 1,1870 Error::<T>::BadCreateRefungibleCall,1871 );1872 let item_owner = item.owner.first().expect("only one owner is defined");18731874 let value = item_owner.fraction;1875 let owner = item_owner.owner.clone();18761877 Self::add_token_index(collection_id, current_index, &owner)?;18781879 <ItemListIndex>::insert(collection_id, current_index);1880 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18811882 // Update balance1883 let new_balance = <Balance<T>>::get(collection_id, &owner)1884 .checked_add(value)1885 .ok_or(Error::<T>::NumOverflow)?;1886 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);18871888 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1889 Ok(())1890 }18911892 fn add_nft_item(collection_id: CollectionId, item: NftItemType<T::AccountId>) -> DispatchResult {1893 let current_index = <ItemListIndex>::get(collection_id)1894 .checked_add(1)1895 .ok_or(Error::<T>::NumOverflow)?;18961897 let item_owner = item.owner.clone();1898 Self::add_token_index(collection_id, current_index, &item.owner)?;18991900 <ItemListIndex>::insert(collection_id, current_index);1901 <NftItemList<T>>::insert(collection_id, current_index, item);19021903 // Update balance1904 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1905 .checked_add(1)1906 .ok_or(Error::<T>::NumOverflow)?;1907 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19081909 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1910 Ok(())1911 }19121913 fn burn_refungible_item(1914 collection_id: CollectionId,1915 item_id: TokenId,1916 owner: &T::AccountId,1917 ) -> DispatchResult {1918 ensure!(1919 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1920 Error::<T>::TokenNotFound1921 );1922 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1923 let rft_balance = token1924 .owner1925 .iter()1926 .find(|&i| i.owner == *owner)1927 .ok_or(Error::<T>::TokenNotFound)?;1928 Self::remove_token_index(collection_id, item_id, owner)?;19291930 // update balance1931 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1932 .checked_sub(rft_balance.fraction)1933 .ok_or(Error::<T>::NumOverflow)?;1934 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19351936 // Re-create owners list with sender removed1937 let index = token1938 .owner1939 .iter()1940 .position(|i| i.owner == *owner)1941 .expect("owned item is exists");1942 token.owner.remove(index);1943 let owner_count = token.owner.len();19441945 // Burn the token completely if this was the last (only) owner1946 if owner_count == 0 {1947 <ReFungibleItemList<T>>::remove(collection_id, item_id);1948 }1949 else {1950 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1951 }19521953 Ok(())1954 }19551956 fn burn_nft_item(collection_id: CollectionId, item_id: TokenId) -> DispatchResult {1957 ensure!(1958 <NftItemList<T>>::contains_key(collection_id, item_id),1959 Error::<T>::TokenNotFound1960 );1961 let item = <NftItemList<T>>::get(collection_id, item_id);1962 Self::remove_token_index(collection_id, item_id, &item.owner)?;19631964 // update balance1965 let new_balance = <Balance<T>>::get(collection_id, &item.owner)1966 .checked_sub(1)1967 .ok_or(Error::<T>::NumOverflow)?;1968 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1969 <NftItemList<T>>::remove(collection_id, item_id);19701971 Ok(())1972 }19731974 fn burn_fungible_item(owner: &T::AccountId, collection_id: CollectionId, value: u128) -> DispatchResult {1975 ensure!(1976 <FungibleItemList<T>>::contains_key(collection_id, owner),1977 Error::<T>::TokenNotFound1978 );1979 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);1980 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19811982 // update balance1983 let new_balance = <Balance<T>>::get(collection_id, owner)1984 .checked_sub(value)1985 .ok_or(Error::<T>::NumOverflow)?;1986 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19871988 if balance.value - value > 0 {1989 balance.value -= value;1990 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);1991 }1992 else {1993 <FungibleItemList<T>>::remove(collection_id, owner);1994 }19951996 Ok(())1997 }19981999 fn collection_exists(collection_id: CollectionId) -> DispatchResult {2000 ensure!(2001 <Collection<T>>::contains_key(collection_id),2002 Error::<T>::CollectionNotFound2003 );2004 Ok(())2005 }20062007 fn check_owner_permissions(collection_id: CollectionId, subject: T::AccountId) -> DispatchResult {2008 Self::collection_exists(collection_id)?;20092010 let target_collection = <Collection<T>>::get(collection_id);2011 ensure!(2012 subject == target_collection.owner,2013 Error::<T>::NoPermission2014 );20152016 Ok(())2017 }20182019 fn is_owner_or_admin_permissions(collection_id: CollectionId, subject: T::AccountId) -> bool {2020 let target_collection = <Collection<T>>::get(collection_id);2021 let mut result: bool = subject == target_collection.owner;2022 let exists = <AdminList<T>>::contains_key(collection_id);20232024 if !result & exists {2025 if <AdminList<T>>::get(collection_id).contains(&subject) {2026 result = true2027 }2028 }20292030 result2031 }20322033 fn check_owner_or_admin_permissions(2034 collection_id: CollectionId,2035 subject: T::AccountId,2036 ) -> DispatchResult {2037 Self::collection_exists(collection_id)?;2038 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());20392040 ensure!(2041 result,2042 Error::<T>::NoPermission2043 );2044 Ok(())2045 }20462047 fn owned_amount(2048 subject: T::AccountId,2049 collection_id: CollectionId,2050 item_id: TokenId,2051 ) -> Option<u128> {2052 let target_collection = <Collection<T>>::get(collection_id);20532054 match target_collection.mode {2055 CollectionMode::NFT => {2056 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2057 return Some(1)2058 }2059 None2060 },2061 CollectionMode::Fungible(_) => {2062 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2063 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2064 .value);2065 }2066 None2067 },2068 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2069 .owner2070 .iter()2071 .find(|i| i.owner == subject)2072 .map(|i| i.fraction),2073 CollectionMode::Invalid => None,2074 }2075 }20762077 fn is_item_owner(subject: T::AccountId, collection_id: CollectionId, item_id: TokenId) -> bool {2078 let target_collection = <Collection<T>>::get(collection_id);20792080 match target_collection.mode {2081 CollectionMode::NFT => {2082 <NftItemList<T>>::get(collection_id, item_id).owner == subject2083 }2084 CollectionMode::Fungible(_) => {2085 <FungibleItemList<T>>::contains_key(collection_id, &subject)2086 }2087 CollectionMode::ReFungible => {2088 <ReFungibleItemList<T>>::get(collection_id, item_id)2089 .owner2090 .iter()2091 .any(|i| i.owner == subject)2092 }2093 CollectionMode::Invalid => false,2094 }2095 }20962097 fn check_white_list(collection_id: CollectionId, address: &T::AccountId) -> DispatchResult {2098 let mes = Error::<T>::AddresNotInWhiteList;2099 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21002101 Ok(())2102 }21032104 /// Check if token exists. In case of Fungible, check if there is an entry for 2105 /// the owner in fungible balances double map2106 fn token_exists(2107 collection_id: CollectionId,2108 item_id: TokenId,2109 owner: &T::AccountId2110 ) -> DispatchResult {2111 let target_collection = <Collection<T>>::get(collection_id);2112 let exists = match target_collection.mode2113 {2114 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2115 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2116 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2117 _ => false2118 };21192120 ensure!(exists == true, Error::<T>::TokenNotFound);2121 Ok(())2122 }21232124 fn transfer_fungible(2125 collection_id: CollectionId,2126 value: u128,2127 owner: &T::AccountId,2128 recipient: &T::AccountId,2129 ) -> DispatchResult {2130 Self::token_exists(collection_id, 0, owner)?;21312132 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2133 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21342135 // Send balance to recipient (updates balanceOf of recipient)2136 Self::add_fungible_item(collection_id, recipient, value)?;21372138 // update balanceOf of sender2139 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21402141 // Reduce or remove sender2142 if balance.value == value {2143 <FungibleItemList<T>>::remove(collection_id, owner);2144 }2145 else {2146 balance.value -= value;2147 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2148 }21492150 Ok(())2151 }21522153 fn transfer_refungible(2154 collection_id: CollectionId,2155 item_id: TokenId,2156 value: u128,2157 owner: T::AccountId,2158 new_owner: T::AccountId,2159 ) -> DispatchResult {2160 Self::token_exists(collection_id, item_id, &owner)?;21612162 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2163 let item = full_item2164 .owner2165 .iter()2166 .filter(|i| i.owner == owner)2167 .next()2168 .ok_or(Error::<T>::TokenNotFound)?;2169 let amount = item.fraction;21702171 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21722173 // update balance2174 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2175 .checked_sub(value)2176 .ok_or(Error::<T>::NumOverflow)?;2177 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);21782179 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2180 .checked_add(value)2181 .ok_or(Error::<T>::NumOverflow)?;2182 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);21832184 let old_owner = item.owner.clone();2185 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21862187 // transfer2188 if amount == value && !new_owner_has_account {2189 // change owner2190 // new owner do not have account2191 let mut new_full_item = full_item.clone();2192 new_full_item2193 .owner2194 .iter_mut()2195 .find(|i| i.owner == owner)2196 .expect("old owner does present in refungible")2197 .owner = new_owner.clone();2198 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21992200 // update index collection2201 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2202 } else {2203 let mut new_full_item = full_item.clone();2204 new_full_item2205 .owner2206 .iter_mut()2207 .find(|i| i.owner == owner)2208 .expect("old owner does present in refungible")2209 .fraction -= value;22102211 // separate amount2212 if new_owner_has_account {2213 // new owner has account2214 new_full_item2215 .owner2216 .iter_mut()2217 .find(|i| i.owner == new_owner)2218 .expect("new owner has account")2219 .fraction += value;2220 } else {2221 // new owner do not have account2222 new_full_item.owner.push(Ownership {2223 owner: new_owner.clone(),2224 fraction: value,2225 });2226 Self::add_token_index(collection_id, item_id, &new_owner)?;2227 }22282229 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2230 }22312232 Ok(())2233 }22342235 fn transfer_nft(2236 collection_id: CollectionId,2237 item_id: TokenId,2238 sender: T::AccountId,2239 new_owner: T::AccountId,2240 ) -> DispatchResult {2241 Self::token_exists(collection_id, item_id, &sender)?;22422243 let mut item = <NftItemList<T>>::get(collection_id, item_id);22442245 ensure!(2246 sender == item.owner,2247 Error::<T>::MustBeTokenOwner2248 );22492250 // update balance2251 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2252 .checked_sub(1)2253 .ok_or(Error::<T>::NumOverflow)?;2254 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22552256 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2257 .checked_add(1)2258 .ok_or(Error::<T>::NumOverflow)?;2259 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22602261 // change owner2262 let old_owner = item.owner.clone();2263 item.owner = new_owner.clone();2264 <NftItemList<T>>::insert(collection_id, item_id, item);22652266 // update index collection2267 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22682269 Ok(())2270 }2271 2272 fn set_re_fungible_variable_data(2273 collection_id: CollectionId,2274 item_id: TokenId,2275 data: Vec<u8>2276 ) -> DispatchResult {2277 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);22782279 item.variable_data = data;22802281 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22822283 Ok(())2284 }22852286 fn set_nft_variable_data(2287 collection_id: CollectionId,2288 item_id: TokenId,2289 data: Vec<u8>2290 ) -> DispatchResult {2291 let mut item = <NftItemList<T>>::get(collection_id, item_id);2292 2293 item.variable_data = data;22942295 <NftItemList<T>>::insert(collection_id, item_id, item);2296 2297 Ok(())2298 }22992300 fn init_collection(item: &CollectionType<T::AccountId>) {2301 // check params2302 assert!(2303 item.decimal_points <= MAX_DECIMAL_POINTS,2304 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2305 );2306 assert!(2307 item.name.len() <= 64,2308 "Collection name can not be longer than 63 char"2309 );2310 assert!(2311 item.name.len() <= 256,2312 "Collection description can not be longer than 255 char"2313 );2314 assert!(2315 item.token_prefix.len() <= 16,2316 "Token prefix can not be longer than 15 char"2317 );23182319 // Generate next collection ID2320 let next_id = CreatedCollectionCount::get()2321 .checked_add(1)2322 .unwrap();23232324 CreatedCollectionCount::put(next_id);2325 }23262327 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2328 let current_index = <ItemListIndex>::get(collection_id)2329 .checked_add(1)2330 .unwrap();23312332 let item_owner = item.owner.clone();2333 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23342335 <ItemListIndex>::insert(collection_id, current_index);23362337 // Update balance2338 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2339 .checked_add(1)2340 .unwrap();2341 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2342 }23432344 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2345 let current_index = <ItemListIndex>::get(collection_id)2346 .checked_add(1)2347 .unwrap();23482349 Self::add_token_index(collection_id, current_index, owner).unwrap();23502351 <ItemListIndex>::insert(collection_id, current_index);23522353 // Update balance2354 let new_balance = <Balance<T>>::get(collection_id, owner)2355 .checked_add(item.value)2356 .unwrap();2357 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2358 }23592360 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2361 let current_index = <ItemListIndex>::get(collection_id)2362 .checked_add(1)2363 .unwrap();23642365 let value = item.owner.first().unwrap().fraction;2366 let owner = item.owner.first().unwrap().owner.clone();23672368 Self::add_token_index(collection_id, current_index, &owner).unwrap();23692370 <ItemListIndex>::insert(collection_id, current_index);23712372 // Update balance2373 let new_balance = <Balance<T>>::get(collection_id, &owner)2374 .checked_add(value)2375 .unwrap();2376 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2377 }23782379 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {23802381 // add to account limit2382 if <AccountItemCount<T>>::contains_key(owner) {23832384 // bound Owned tokens by a single address2385 let count = <AccountItemCount<T>>::get(owner);2386 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);23872388 <AccountItemCount<T>>::insert(owner.clone(), count2389 .checked_add(1)2390 .ok_or(Error::<T>::NumOverflow)?);2391 }2392 else {2393 <AccountItemCount<T>>::insert(owner.clone(), 1);2394 }23952396 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2397 if list_exists {2398 let mut list = <AddressTokens<T>>::get(collection_id, owner);2399 let item_contains = list.contains(&item_index.clone());24002401 if !item_contains {2402 list.push(item_index.clone());2403 }24042405 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2406 } else {2407 let mut itm = Vec::new();2408 itm.push(item_index.clone());2409 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2410 }24112412 Ok(())2413 }24142415 fn remove_token_index(2416 collection_id: CollectionId,2417 item_index: TokenId,2418 owner: &T::AccountId,2419 ) -> DispatchResult {24202421 // update counter2422 <AccountItemCount<T>>::insert(owner.clone(), 2423 <AccountItemCount<T>>::get(owner)2424 .checked_sub(1)2425 .ok_or(Error::<T>::NumOverflow)?);242624272428 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2429 if list_exists {2430 let mut list = <AddressTokens<T>>::get(collection_id, owner);2431 let item_contains = list.contains(&item_index.clone());24322433 if item_contains {2434 list.retain(|&item| item != item_index);2435 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2436 }2437 }24382439 Ok(())2440 }24412442 fn move_token_index(2443 collection_id: CollectionId,2444 item_index: TokenId,2445 old_owner: &T::AccountId,2446 new_owner: &T::AccountId,2447 ) -> DispatchResult {2448 Self::remove_token_index(collection_id, item_index, old_owner)?;2449 Self::add_token_index(collection_id, item_index, new_owner)?;24502451 Ok(())2452 }2453 2454 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2455 if <ContractOwner<T>>::contains_key(contract.clone()) {2456 let owner = <ContractOwner<T>>::get(contract);2457 ensure!(account == owner, Error::<T>::NoPermission);2458 } else {2459 fail!(Error::<T>::NoPermission);2460 }24612462 Ok(())2463 }2464}24652466////////////////////////////////////////////////////////////////////////////////////////////////////2467// Economic models2468// #region24692470/// Fee multiplier.2471pub type Multiplier = FixedU128;24722473type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;24742475/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2476/// in the queue.2477#[derive(Encode, Decode, Clone, Eq, PartialEq)]2478pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);24792480impl<T: Config + Send + Sync> sp_std::fmt::Debug 2481 for ChargeTransactionPayment<T>2482{2483 #[cfg(feature = "std")]2484 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2485 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2486 }2487 #[cfg(not(feature = "std"))]2488 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2489 Ok(())2490 }2491}24922493impl<T: Config> ChargeTransactionPayment<T>2494where2495 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2496 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2497 T::AccountId: AsRef<[u8]>,2498 T::AccountId: UncheckedFrom<T::Hash>,2499{2500 fn traditional_fee(2501 len: usize,2502 info: &DispatchInfoOf<T::Call>,2503 tip: BalanceOf<T>,2504 ) -> BalanceOf<T>2505 where2506 T::Call: Dispatchable<Info = DispatchInfo>,2507 {2508 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2509 }25102511 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2512 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2513 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2514 let len_saturation = max_block_length as u64 / (len as u64).max(1);2515 let coefficient: BalanceOf<T> = weight_saturation2516 .min(len_saturation)2517 .saturated_into::<BalanceOf<T>>();2518 final_fee2519 .saturating_mul(coefficient)2520 .saturated_into::<TransactionPriority>()2521 }25222523 fn withdraw_fee(2524 &self,2525 who: &T::AccountId,2526 call: &T::Call,2527 info: &DispatchInfoOf<T::Call>,2528 len: usize,2529 ) -> Result<2530 (2531 BalanceOf<T>,2532 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2533 ),2534 TransactionValidityError,2535 > {2536 let tip = self.0;25372538 // Set fee based on call type. Creating collection costs 1 Unique.2539 // All other transactions have traditional fees so far2540 // let fee = match call.is_sub_type() {2541 // Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),2542 // _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes2543 // // _ => <BalanceOf<T>>::from(100)2544 // };2545 let fee = Self::traditional_fee(len, info, tip);25462547 // Only mess with balances if fee is not zero.2548 if fee.is_zero() {2549 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2550 .map(|i| (fee, i));2551 }25522553 // Determine who is paying transaction fee based on ecnomic model2554 // Parse call to extract collection ID and access collection sponsor2555 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2556 Some(Call::create_item(collection_id, _owner, _properties)) => {25572558 // sponsor timeout2559 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25602561 let collection = <Collection<T>>::get(collection_id);25622563 let limit = collection.limits.sponsor_transfer_timeout;2564 let mut sponsored = true;2565 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2566 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2567 let limit_time = last_tx_block + limit.into();2568 if block_number <= limit_time {2569 sponsored = false;2570 }2571 }2572 if sponsored {2573 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);2574 }25752576 // check free create limit2577 if (collection.limits.sponsored_data_size >= (_properties.len() as u32)) &&2578 (sponsored)2579 {2580 collection.sponsorship.sponsor()2581 .cloned()2582 .unwrap_or_default()2583 } else {2584 T::AccountId::default()2585 }2586 }2587 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2588 2589 let mut sponsor_transfer = false;2590 if <Collection<T>>::get(collection_id).sponsorship.confirmed() {25912592 let collection_limits = <Collection<T>>::get(collection_id).limits;2593 let collection_mode = <Collection<T>>::get(collection_id).mode;2594 2595 // sponsor timeout2596 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2597 sponsor_transfer = match collection_mode {2598 CollectionMode::NFT => {2599 2600 // get correct limit2601 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2602 collection_limits.sponsor_transfer_timeout2603 } else {2604 ChainLimit::get().nft_sponsor_transfer_timeout2605 };2606 2607 let mut sponsored = true;2608 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2609 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2610 let limit_time = last_tx_block + limit.into();2611 if block_number <= limit_time {2612 sponsored = false;2613 }2614 }2615 if sponsored {2616 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2617 }26182619 sponsored2620 }2621 CollectionMode::Fungible(_) => {2622 2623 // get correct limit2624 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2625 collection_limits.sponsor_transfer_timeout2626 } else {2627 ChainLimit::get().fungible_sponsor_transfer_timeout2628 };2629 2630 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2631 let mut sponsored = true;2632 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2633 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2634 let limit_time = last_tx_block + limit.into();2635 if block_number <= limit_time {2636 sponsored = false;2637 }2638 }2639 if sponsored {2640 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2641 }26422643 sponsored2644 }2645 CollectionMode::ReFungible => {2646 2647 // get correct limit2648 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2649 collection_limits.sponsor_transfer_timeout2650 } else {2651 ChainLimit::get().refungible_sponsor_transfer_timeout2652 };2653 2654 let mut sponsored = true;2655 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2656 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2657 let limit_time = last_tx_block + limit.into();2658 if block_number <= limit_time {2659 sponsored = false;2660 }2661 }2662 if sponsored {2663 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2664 }26652666 sponsored2667 }2668 _ => {2669 false2670 },2671 };2672 }26732674 if !sponsor_transfer {2675 T::AccountId::default()2676 } else {2677 <Collection<T>>::get(collection_id).sponsorship.sponsor()2678 .cloned()2679 .unwrap_or_default()2680 }2681 }26822683 _ => T::AccountId::default(),2684 };26852686 // Sponsor smart contracts2687 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {26882689 // On instantiation: set the contract owner2690 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {26912692 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2693 &who,2694 code_hash,2695 salt,2696 );2697 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());26982699 T::AccountId::default()2700 },27012702 // On instantiation with code: set the contract owner2703 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27042705 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2706 &who,2707 &T::Hashing::hash(&_code),2708 _salt,2709 );27102711 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27122713 T::AccountId::default()2714 }27152716 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2717 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27182719 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27202721 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2722 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2723 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2724 2725 if !owned_contract && white_list_enabled {2726 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2727 return Err(InvalidTransaction::Call.into());2728 }2729 }27302731 let mut sponsor_transfer = false;2732 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2733 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2734 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2735 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2736 let limit_time = last_tx_block + rate_limit;27372738 if block_number >= limit_time {2739 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2740 sponsor_transfer = true;2741 }2742 } else {2743 sponsor_transfer = false;2744 }2745 2746 2747 let mut sp = T::AccountId::default();2748 if sponsor_transfer {2749 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2750 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2751 sp = called_contract;2752 }2753 }2754 }27552756 sp2757 },27582759 _ => sponsor,2760 };27612762 let mut who_pays_fee: T::AccountId = sponsor.clone();2763 if sponsor == T::AccountId::default() {2764 who_pays_fee = who.clone();2765 }27662767 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2768 .map(|i| (fee, i))2769 }2770}277127722773impl<T: Config + Send + Sync> SignedExtension2774 for ChargeTransactionPayment<T>2775where2776 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2777 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2778 T::AccountId: AsRef<[u8]>,2779 T::AccountId: UncheckedFrom<T::Hash>,2780{2781 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2782 type AccountId = T::AccountId;2783 type Call = T::Call;2784 type AdditionalSigned = ();2785 type Pre = (2786 // tip2787 BalanceOf<T>,2788 // who pays fee2789 Self::AccountId,2790 // imbalance resulting from withdrawing the fee2791 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2792 );2793 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2794 Ok(())2795 }27962797 fn validate(2798 &self,2799 who: &Self::AccountId,2800 call: &Self::Call,2801 info: &DispatchInfoOf<Self::Call>,2802 len: usize,2803 ) -> TransactionValidity {2804 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2805 Ok(ValidTransaction {2806 priority: Self::get_priority(len, info, fee),2807 ..Default::default()2808 })2809 }28102811 fn pre_dispatch(2812 self,2813 who: &Self::AccountId,2814 call: &Self::Call,2815 info: &DispatchInfoOf<Self::Call>,2816 len: usize,2817 ) -> Result<Self::Pre, TransactionValidityError> {2818 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2819 Ok((self.0, who.clone(), imbalance))2820 }28212822 fn post_dispatch(2823 pre: Self::Pre,2824 info: &DispatchInfoOf<Self::Call>,2825 post_info: &PostDispatchInfoOf<Self::Call>,2826 len: usize,2827 _result: &DispatchResult,2828 ) -> Result<(), TransactionValidityError> {2829 let (tip, who, imbalance) = pre;2830 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2831 len as u32,2832 info,2833 post_info,2834 tip,2835 );2836 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2837 Ok(())2838 }2839}28402841// #endregion