difftreelog
feat add Approved event
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 core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue,32 transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38 traits::{39 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40 },41 transaction_validity::{42 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43 },44 FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263// Structs64// #region6566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73 Invalid,74 NFT,75 // decimal points76 Fungible(DecimalPoints),77 ReFungible,78}7980impl Default for CollectionMode {81 fn default() -> Self {82 Self::Invalid83 }84}8586impl Into<u8> for CollectionMode {87 fn into(self) -> u8 {88 match self {89 CollectionMode::Invalid => 0,90 CollectionMode::NFT => 1,91 CollectionMode::Fungible(_) => 2,92 CollectionMode::ReFungible => 3,93 }94 }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100 Normal,101 WhiteList,102}103impl Default for AccessMode {104 fn default() -> Self {105 Self::Normal106 }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112 ImageURL,113 Unique,114}115impl Default for SchemaVersion {116 fn default() -> Self {117 Self::ImageURL118 }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124 pub owner: AccountId,125 pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131 /// The fees are applied to the transaction sender132 Disabled,133 Unconfirmed(AccountId),134 /// Transactions are sponsored by specified account135 Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139 fn sponsor(&self) -> Option<&AccountId> {140 match self {141 Self::Confirmed(sponsor) => Some(sponsor),142 _ => None,143 }144 }145146 fn pending_sponsor(&self) -> Option<&AccountId> {147 match self {148 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149 _ => None,150 }151 }152153 fn confirmed(&self) -> bool {154 matches!(self, Self::Confirmed(_))155 }156}157158impl<T> Default for SponsorshipState<T> {159 fn default() -> Self {160 Self::Disabled161 }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167 pub owner: T::AccountId,168 pub mode: CollectionMode,169 pub access: AccessMode,170 pub decimal_points: DecimalPoints,171 pub name: Vec<u16>, // 64 include null escape char172 pub description: Vec<u16>, // 256 include null escape char173 pub token_prefix: Vec<u8>, // 16 include null escape char174 pub mint_mode: bool,175 pub offchain_schema: Vec<u8>,176 pub schema_version: SchemaVersion,177 pub sponsorship: SponsorshipState<T::AccountId>,178 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 179 pub variable_on_chain_schema: Vec<u8>, //180 pub const_on_chain_schema: Vec<u8>, //181}182183pub struct CollectionHandle<T: Config> {184 pub id: CollectionId,185 collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189 type Target = Collection<T>;190191 fn deref(&self) -> &Self::Target {192 &self.collection193 }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197 fn deref_mut(&mut self) -> &mut Self::Target {198 &mut self.collection199 }200}201202#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205 pub owner: AccountId,206 pub const_data: Vec<u8>,207 pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213 pub value: u128,214}215216#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219 pub owner: Vec<Ownership<AccountId>>,220 pub const_data: Vec<u8>,221 pub variable_data: Vec<u8>,222}223224// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]225// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]226// pub struct VestingItem<AccountId, Moment> {227// pub sender: AccountId,228// pub recipient: AccountId,229// pub collection_id: CollectionId,230// pub item_id: TokenId,231// pub amount: u64,232// pub vesting_date: Moment,233// }234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238 pub account_token_ownership_limit: u32,239 pub sponsored_data_size: u32,240 /// None - setVariableMetadata is not sponsored241 /// Some(v) - setVariableMetadata is sponsored 242 /// if there is v block between txs243 pub sponsored_data_rate_limit: Option<BlockNumber>,244 pub token_limit: u32,245246 // Timeouts for item types in passed blocks247 pub sponsor_transfer_timeout: u32,248 pub owner_can_transfer: bool,249 pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253 fn default() -> Self {254 Self { 255 account_token_ownership_limit: 10_000_000, 256 token_limit: u32::max_value(),257 sponsored_data_size: u32::MAX, 258 sponsored_data_rate_limit: None,259 sponsor_transfer_timeout: 14400,260 owner_can_transfer: true,261 owner_can_destroy: true262 }263 }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269 pub collection_numbers_limit: u32,270 pub account_token_ownership_limit: u32,271 pub collections_admins_limit: u64,272 pub custom_data_limit: u32,273274 // Timeouts for item types in passed blocks275 pub nft_sponsor_transfer_timeout: u32,276 pub fungible_sponsor_transfer_timeout: u32,277 pub refungible_sponsor_transfer_timeout: u32,278279 // Schema limits280 pub offchain_schema_limit: u32,281 pub variable_on_chain_schema_limit: u32,282 pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286 fn create_collection() -> Weight;287 fn destroy_collection() -> Weight;288 fn add_to_white_list() -> Weight;289 fn remove_from_white_list() -> Weight;290 fn set_public_access_mode() -> Weight;291 fn set_mint_permission() -> Weight;292 fn change_collection_owner() -> Weight;293 fn add_collection_admin() -> Weight;294 fn remove_collection_admin() -> Weight;295 fn set_collection_sponsor() -> Weight;296 fn confirm_sponsorship() -> Weight;297 fn remove_collection_sponsor() -> Weight;298 fn create_item(s: usize) -> Weight;299 fn burn_item() -> Weight;300 fn transfer() -> Weight;301 fn approve() -> Weight;302 fn transfer_from() -> Weight;303 fn set_offchain_schema() -> Weight;304 fn set_const_on_chain_schema() -> Weight;305 fn set_variable_on_chain_schema() -> Weight;306 fn set_variable_meta_data() -> Weight;307 fn enable_contract_sponsoring() -> Weight;308 fn set_schema_version() -> Weight;309 fn set_chain_limits() -> Weight;310 fn set_contract_sponsoring_rate_limit() -> Weight;311 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312 fn toggle_contract_white_list() -> Weight;313 fn add_to_contract_white_list() -> Weight;314 fn remove_from_contract_white_list() -> Weight;315 fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321 pub const_data: Vec<u8>,322 pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328 pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334 pub const_data: Vec<u8>,335 pub variable_data: Vec<u8>,336 pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342 NFT(CreateNftData),343 Fungible(CreateFungibleData),344 ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348 pub fn len(&self) -> usize {349 let len = match self {350 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352 _ => 0353 };354 355 return len;356 }357}358359impl From<CreateNftData> for CreateItemData {360 fn from(item: CreateNftData) -> Self {361 CreateItemData::NFT(item)362 }363}364365impl From<CreateReFungibleData> for CreateItemData {366 fn from(item: CreateReFungibleData) -> Self {367 CreateItemData::ReFungible(item)368 }369}370371impl From<CreateFungibleData> for CreateItemData {372 fn from(item: CreateFungibleData) -> Self {373 CreateItemData::Fungible(item)374 }375}376377378decl_error! {379 /// Error for non-fungible-token module.380 pub enum Error for Module<T: Config> {381 /// Total collections bound exceeded.382 TotalCollectionsLimitExceeded,383 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.384 CollectionDecimalPointLimitExceeded, 385 /// Collection name can not be longer than 63 char.386 CollectionNameLimitExceeded, 387 /// Collection description can not be longer than 255 char.388 CollectionDescriptionLimitExceeded, 389 /// Token prefix can not be longer than 15 char.390 CollectionTokenPrefixLimitExceeded,391 /// This collection does not exist.392 CollectionNotFound,393 /// Item not exists.394 TokenNotFound,395 /// Admin not found396 AdminNotFound,397 /// Arithmetic calculation overflow.398 NumOverflow, 399 /// Account already has admin role.400 AlreadyAdmin, 401 /// You do not own this collection.402 NoPermission,403 /// This address is not set as sponsor, use setCollectionSponsor first.404 ConfirmUnsetSponsorFail,405 /// Collection is not in mint mode.406 PublicMintingNotAllowed,407 /// Sender parameter and item owner must be equal.408 MustBeTokenOwner,409 /// Item balance not enough.410 TokenValueTooLow,411 /// Size of item is too large.412 NftSizeLimitExceeded,413 /// No approve found414 ApproveNotFound,415 /// Requested value more than approved.416 TokenValueNotEnough,417 /// Only approved addresses can call this method.418 ApproveRequired,419 /// Address is not in white list.420 AddresNotInWhiteList,421 /// Number of collection admins bound exceeded.422 CollectionAdminsLimitExceeded,423 /// Owned tokens by a single address bound exceeded.424 AddressOwnershipLimitExceeded,425 /// Length of items properties must be greater than 0.426 EmptyArgument,427 /// const_data exceeded data limit.428 TokenConstDataLimitExceeded,429 /// variable_data exceeded data limit.430 TokenVariableDataLimitExceeded,431 /// Not NFT item data used to mint in NFT collection.432 NotNftDataUsedToMintNftCollectionToken,433 /// Not Fungible item data used to mint in Fungible collection.434 NotFungibleDataUsedToMintFungibleCollectionToken,435 /// Not Re Fungible item data used to mint in Re Fungible collection.436 NotReFungibleDataUsedToMintReFungibleCollectionToken,437 /// Unexpected collection type.438 UnexpectedCollectionType,439 /// Can't store metadata in fungible tokens.440 CantStoreMetadataInFungibleTokens,441 /// Collection token limit exceeded442 CollectionTokenLimitExceeded,443 /// Account token limit exceeded per collection444 AccountTokenLimitExceeded,445 /// Collection limit bounds per collection exceeded446 CollectionLimitBoundsExceeded,447 /// Tried to enable permissions which are only permitted to be disabled448 OwnerPermissionsCantBeReverted,449 /// Schema data size limit bound exceeded450 SchemaDataLimitExceeded,451 /// Maximum refungibility exceeded452 WrongRefungiblePieces,453 /// createRefungible should be called with one owner454 BadCreateRefungibleCall,455 }456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461 /// Weight information for extrinsics in this pallet.462 type WeightInfo: WeightInfo;463464 type Currency: Currency<Self::AccountId>;465 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466 type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472// #endregion473474// # Used definitions475//476// ## User control levels477//478// chain-controlled - key is uncontrolled by user479// i.e autoincrementing index480// can use non-cryptographic hash481// real - key is controlled by user482// but it is hard to generate enough colliding values, i.e owner of signed txs483// can use non-cryptographic hash484// controlled - key is completly controlled by users485// i.e maps with mutable keys486// should use cryptographic hash487//488// ## User control level downgrade reasons489//490// ?1 - chain-controlled -> controlled491// collections/tokens can be destroyed, resulting in massive holes492// ?2 - chain-controlled -> controlled493// same as ?1, but can be only added, resulting in easier exploitation494// ?3 - real -> controlled495// no confirmation required, so addresses can be easily generated496decl_storage! {497 trait Store for Module<T: Config> as Nft {498499 //#region Private members500 /// Id of next collection501 CreatedCollectionCount: u32;502 /// Used for migrations503 ChainVersion: u64;504 /// Id of last collection token505 /// Collection id (controlled?1)506 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507 //#endregion508509 //#region Chain limits struct510 pub ChainLimit get(fn chain_limit) config(): ChainLimits;511 //#endregion512513 //#region Bound counters514 /// Amount of collections destroyed, used for total amount tracking with515 /// CreatedCollectionCount516 DestroyedCollectionCount: u32;517 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)518 /// Account id (real)519 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520 //#endregion521522 //#region Basic collections523 /// Collection info524 /// Collection id (controlled?1)525 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526 /// List of collection admins527 /// Collection id (controlled?2)528 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529 /// Whitelisted collection users530 /// Collection id (controlled?2), user id (controlled?3)531 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532 //#endregion533534 /// How many of collection items user have535 /// Collection id (controlled?2), account id (real)536 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538 /// Amount of items which spender can transfer out of owners account (via transferFrom)539 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))540 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;541542 //#region Item collections543 /// Collection id (controlled?2), token id (controlled?1)544 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;545 /// Collection id (controlled?2), owner (controlled?2)546 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;547 /// Collection id (controlled?2), token id (controlled?1)548 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;549 //#endregion550551 //#region Index list552 /// Collection id (controlled?2), tokens owner (controlled?2)553 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;554 //#endregion555556 //#region Tokens transfer rate limit baskets557 /// (Collection id (controlled?2), who created (real))558 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;559 /// Collection id (controlled?2), token id (controlled?2)560 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;561 /// Collection id (controlled?2), owning user (real)562 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;563 /// Collection id (controlled?2), token id (controlled?2)564 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;565 //#endregion566567 /// Variable metadata sponsoring568 /// Collection id (controlled?2), token id (controlled?2)569 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;570 571 //#region Contract Sponsorship and Ownership572 /// Contract address (real)573 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;574 /// Contract address (real)575 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;576 /// (Contract address(real), caller (real))577 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;578 /// Contract address (real)579 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;580 /// Contract address (real)581 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 582 /// Contract address (real) => Whitelisted user (controlled?3)583 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 584 //#endregion585 }586 add_extra_genesis {587 build(|config: &GenesisConfig<T>| {588 // Modification of storage589 for (_num, _c) in &config.collection_id {590 <Module<T>>::init_collection(_c);591 }592593 for (_num, _c, _i) in &config.nft_item_id {594 <Module<T>>::init_nft_token(*_c, _i);595 }596597 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {598 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);599 }600601 for (_num, _c, _i) in &config.refungible_item_id {602 <Module<T>>::init_refungible_token(*_c, _i);603 }604 })605 }606}607608decl_event!(609 pub enum Event<T>610 where611 AccountId = <T as system::Config>::AccountId,612 {613 /// New collection was created614 /// 615 /// # Arguments616 /// 617 /// * collection_id: Globally unique identifier of newly created collection.618 /// 619 /// * mode: [CollectionMode] converted into u8.620 /// 621 /// * account_id: Collection owner.622 Created(CollectionId, u8, AccountId),623624 /// New item was created.625 /// 626 /// # Arguments627 /// 628 /// * collection_id: Id of the collection where item was created.629 /// 630 /// * item_id: Id of an item. Unique within the collection.631 ///632 /// * recipient: Owner of newly created item 633 ItemCreated(CollectionId, TokenId, AccountId),634635 /// Collection item was burned.636 /// 637 /// # Arguments638 /// 639 /// collection_id.640 /// 641 /// item_id: Identifier of burned NFT.642 ItemDestroyed(CollectionId, TokenId),643644 /// Item was transferred645 ///646 /// * collection_id: Id of collection to which item is belong647 ///648 /// * item_id: Id of an item649 ///650 /// * sender: Original owner of item651 ///652 /// * recipient: New owner of item653 ///654 /// * amount: Always 1 for NFT655 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),656 }657);658659decl_module! {660 pub struct Module<T: Config> for enum Call 661 where 662 origin: T::Origin663 {664 fn deposit_event() = default;665 type Error = Error<T>;666667 fn on_initialize(now: T::BlockNumber) -> Weight {668 0669 }670671 /// 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.672 /// 673 /// # Permissions674 /// 675 /// * Anyone.676 /// 677 /// # Arguments678 /// 679 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.680 /// 681 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.682 /// 683 /// * token_prefix: UTF-8 string with token prefix.684 /// 685 /// * mode: [CollectionMode] collection type and type dependent data.686 // returns collection ID687 #[weight = <T as Config>::WeightInfo::create_collection()]688 #[transactional]689 pub fn create_collection(origin,690 collection_name: Vec<u16>,691 collection_description: Vec<u16>,692 token_prefix: Vec<u8>,693 mode: CollectionMode) -> DispatchResult {694695 // Anyone can create a collection696 let who = ensure_signed(origin)?;697698 // Take a (non-refundable) deposit of collection creation699 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();700 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(701 &T::TreasuryAccountId::get(),702 T::CollectionCreationPrice::get(),703 ));704 <T as Config>::Currency::settle(705 &who,706 imbalance,707 WithdrawReasons::TRANSFER,708 ExistenceRequirement::KeepAlive,709 ).map_err(|_| Error::<T>::NoPermission)?;710711 let decimal_points = match mode {712 CollectionMode::Fungible(points) => points,713 _ => 0714 };715716 let chain_limit = ChainLimit::get();717718 let created_count = CreatedCollectionCount::get();719 let destroyed_count = DestroyedCollectionCount::get();720721 // bound Total number of collections722 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);723724 // check params725 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);726 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);727 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);728 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);729730 // Generate next collection ID731 let next_id = created_count732 .checked_add(1)733 .ok_or(Error::<T>::NumOverflow)?;734735 CreatedCollectionCount::put(next_id);736737 let limits = CollectionLimits {738 sponsored_data_size: chain_limit.custom_data_limit,739 ..Default::default()740 };741742 // Create new collection743 let new_collection = Collection {744 owner: who.clone(),745 name: collection_name,746 mode: mode.clone(),747 mint_mode: false,748 access: AccessMode::Normal,749 description: collection_description,750 decimal_points: decimal_points,751 token_prefix: token_prefix,752 offchain_schema: Vec::new(),753 schema_version: SchemaVersion::ImageURL,754 sponsorship: SponsorshipState::Disabled,755 variable_on_chain_schema: Vec::new(),756 const_on_chain_schema: Vec::new(),757 limits,758 };759760 // Add new collection to map761 <CollectionById<T>>::insert(next_id, new_collection);762763 // call event764 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));765766 Ok(())767 }768769 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.770 /// 771 /// # Permissions772 /// 773 /// * Collection Owner.774 /// 775 /// # Arguments776 /// 777 /// * collection_id: collection to destroy.778 #[weight = <T as Config>::WeightInfo::destroy_collection()]779 #[transactional]780 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {781782 let sender = ensure_signed(origin)?;783 let collection = Self::get_collection(collection_id)?;784 Self::check_owner_permissions(&collection, sender)?;785 if !collection.limits.owner_can_destroy {786 fail!(Error::<T>::NoPermission);787 }788789 <AddressTokens<T>>::remove_prefix(collection_id);790 <Allowances<T>>::remove_prefix(collection_id);791 <Balance<T>>::remove_prefix(collection_id);792 <ItemListIndex>::remove(collection_id);793 <AdminList<T>>::remove(collection_id);794 <CollectionById<T>>::remove(collection_id);795 <WhiteList<T>>::remove_prefix(collection_id);796797 <NftItemList<T>>::remove_prefix(collection_id);798 <FungibleItemList<T>>::remove_prefix(collection_id);799 <ReFungibleItemList<T>>::remove_prefix(collection_id);800801 <NftTransferBasket<T>>::remove_prefix(collection_id);802 <FungibleTransferBasket<T>>::remove_prefix(collection_id);803 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);804805 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);806807 DestroyedCollectionCount::put(DestroyedCollectionCount::get()808 .checked_add(1)809 .ok_or(Error::<T>::NumOverflow)?);810811 Ok(())812 }813814 /// Add an address to white list.815 /// 816 /// # Permissions817 /// 818 /// * Collection Owner819 /// * Collection Admin820 /// 821 /// # Arguments822 /// 823 /// * collection_id.824 /// 825 /// * address.826 #[weight = <T as Config>::WeightInfo::add_to_white_list()]827 #[transactional]828 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{829830 let sender = ensure_signed(origin)?;831 let collection = Self::get_collection(collection_id)?;832 Self::check_owner_or_admin_permissions(&collection, sender)?;833834 <WhiteList<T>>::insert(collection_id, address, true);835 836 Ok(())837 }838839 /// Remove an address from white list.840 /// 841 /// # Permissions842 /// 843 /// * Collection Owner844 /// * Collection Admin845 /// 846 /// # Arguments847 /// 848 /// * collection_id.849 /// 850 /// * address.851 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]852 #[transactional]853 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{854855 let sender = ensure_signed(origin)?;856 let collection = Self::get_collection(collection_id)?;857 Self::check_owner_or_admin_permissions(&collection, sender)?;858859 <WhiteList<T>>::remove(collection_id, address);860861 Ok(())862 }863864 /// Toggle between normal and white list access for the methods with access for `Anyone`.865 /// 866 /// # Permissions867 /// 868 /// * Collection Owner.869 /// 870 /// # Arguments871 /// 872 /// * collection_id.873 /// 874 /// * mode: [AccessMode]875 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]876 #[transactional]877 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult878 {879 let sender = ensure_signed(origin)?;880881 let mut target_collection = Self::get_collection(collection_id)?;882 Self::check_owner_permissions(&target_collection, sender)?;883 target_collection.access = mode;884 Self::save_collection(target_collection);885886 Ok(())887 }888889 /// Allows Anyone to create tokens if:890 /// * White List is enabled, and891 /// * Address is added to white list, and892 /// * This method was called with True parameter893 /// 894 /// # Permissions895 /// * Collection Owner896 ///897 /// # Arguments898 /// 899 /// * collection_id.900 /// 901 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.902 #[weight = <T as Config>::WeightInfo::set_mint_permission()]903 #[transactional]904 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult905 {906 let sender = ensure_signed(origin)?;907908 let mut target_collection = Self::get_collection(collection_id)?;909 Self::check_owner_permissions(&target_collection, sender)?;910 target_collection.mint_mode = mint_permission;911 Self::save_collection(target_collection);912913 Ok(())914 }915916 /// Change the owner of the collection.917 /// 918 /// # Permissions919 /// 920 /// * Collection Owner.921 /// 922 /// # Arguments923 /// 924 /// * collection_id.925 /// 926 /// * new_owner.927 #[weight = <T as Config>::WeightInfo::change_collection_owner()]928 #[transactional]929 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {930931 let sender = ensure_signed(origin)?;932 let mut target_collection = Self::get_collection(collection_id)?;933 Self::check_owner_permissions(&target_collection, sender)?;934 target_collection.owner = new_owner;935 Self::save_collection(target_collection);936937 Ok(())938 }939940 /// Adds an admin of the Collection.941 /// 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. 942 /// 943 /// # Permissions944 /// 945 /// * Collection Owner.946 /// * Collection Admin.947 /// 948 /// # Arguments949 /// 950 /// * collection_id: ID of the Collection to add admin for.951 /// 952 /// * new_admin_id: Address of new admin to add.953 #[weight = <T as Config>::WeightInfo::add_collection_admin()]954 #[transactional]955 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {956957 let sender = ensure_signed(origin)?;958 let collection = Self::get_collection(collection_id)?;959 Self::check_owner_or_admin_permissions(&collection, sender)?;960 let mut admin_arr: Vec<T::AccountId> = Vec::new();961962 if <AdminList<T>>::contains_key(collection_id)963 {964 admin_arr = <AdminList<T>>::get(collection_id);965 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);966 }967968 // Number of collection admins969 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);970971 admin_arr.push(new_admin_id);972 <AdminList<T>>::insert(collection_id, admin_arr);973974 Ok(())975 }976977 /// 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.978 ///979 /// # Permissions980 /// 981 /// * Collection Owner.982 /// * Collection Admin.983 /// 984 /// # Arguments985 /// 986 /// * collection_id: ID of the Collection to remove admin for.987 /// 988 /// * account_id: Address of admin to remove.989 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]990 #[transactional]991 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {992993 let sender = ensure_signed(origin)?;994 let collection = Self::get_collection(collection_id)?;995 Self::check_owner_or_admin_permissions(&collection, sender)?;996 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);997998 let mut admin_arr = <AdminList<T>>::get(collection_id);999 admin_arr.retain(|i| *i != account_id);1000 <AdminList<T>>::insert(collection_id, admin_arr);10011002 Ok(())1003 }10041005 /// # Permissions1006 /// 1007 /// * Collection Owner1008 /// 1009 /// # Arguments1010 /// 1011 /// * collection_id.1012 /// 1013 /// * new_sponsor.1014 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1015 #[transactional]1016 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10171018 let sender = ensure_signed(origin)?;1019 let mut target_collection = Self::get_collection(collection_id)?;1020 Self::check_owner_permissions(&target_collection, sender)?;10211022 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1023 Self::save_collection(target_collection);10241025 Ok(())1026 }10271028 /// # Permissions1029 /// 1030 /// * Sponsor.1031 /// 1032 /// # Arguments1033 /// 1034 /// * collection_id.1035 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1036 #[transactional]1037 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10381039 let sender = ensure_signed(origin)?;10401041 let mut target_collection = Self::get_collection(collection_id)?;1042 ensure!(1043 target_collection.sponsorship.pending_sponsor() == Some(&sender),1044 Error::<T>::ConfirmUnsetSponsorFail1045 );10461047 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1048 Self::save_collection(target_collection);10491050 Ok(())1051 }10521053 /// Switch back to pay-per-own-transaction model.1054 ///1055 /// # Permissions1056 ///1057 /// * Collection owner.1058 /// 1059 /// # Arguments1060 /// 1061 /// * collection_id.1062 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1063 #[transactional]1064 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10651066 let sender = ensure_signed(origin)?;10671068 let mut target_collection = Self::get_collection(collection_id)?;1069 Self::check_owner_permissions(&target_collection, sender)?;10701071 target_collection.sponsorship = SponsorshipState::Disabled;1072 Self::save_collection(target_collection);10731074 Ok(())1075 }10761077 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1078 /// 1079 /// # Permissions1080 /// 1081 /// * Collection Owner.1082 /// * Collection Admin.1083 /// * Anyone if1084 /// * White List is enabled, and1085 /// * Address is added to white list, and1086 /// * MintPermission is enabled (see SetMintPermission method)1087 /// 1088 /// # Arguments1089 /// 1090 /// * collection_id: ID of the collection.1091 /// 1092 /// * owner: Address, initial owner of the NFT.1093 ///1094 /// * data: Token data to store on chain.1095 // #[weight =1096 // (130_000_000 as Weight)1097 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1098 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1099 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11001101 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1102 #[transactional]1103 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11041105 let sender = ensure_signed(origin)?;11061107 let target_collection = Self::get_collection(collection_id)?;11081109 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1110 Self::validate_create_item_args(&target_collection, &data)?;1111 Self::create_item_no_validation(&target_collection, owner, data)?;11121113 Ok(())1114 }11151116 /// This method creates multiple items in a collection created with CreateCollection method.1117 /// 1118 /// # Permissions1119 /// 1120 /// * Collection Owner.1121 /// * Collection Admin.1122 /// * Anyone if1123 /// * White List is enabled, and1124 /// * Address is added to white list, and1125 /// * MintPermission is enabled (see SetMintPermission method)1126 /// 1127 /// # Arguments1128 /// 1129 /// * collection_id: ID of the collection.1130 /// 1131 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1132 /// 1133 /// * owner: Address, initial owner of the NFT.1134 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1135 .map(|data| { data.len() })1136 .sum())]1137 #[transactional]1138 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11391140 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1141 let sender = ensure_signed(origin)?;11421143 let target_collection = Self::get_collection(collection_id)?;11441145 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11461147 for data in &items_data {1148 Self::validate_create_item_args(&target_collection, data)?;1149 }1150 for data in &items_data {1151 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1152 }11531154 Ok(())1155 }11561157 /// Destroys a concrete instance of NFT.1158 /// 1159 /// # Permissions1160 /// 1161 /// * Collection Owner.1162 /// * Collection Admin.1163 /// * Current NFT Owner.1164 /// 1165 /// # Arguments1166 /// 1167 /// * collection_id: ID of the collection.1168 /// 1169 /// * item_id: ID of NFT to burn.1170 #[weight = <T as Config>::WeightInfo::burn_item()]1171 #[transactional]1172 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11731174 let sender = ensure_signed(origin)?;11751176 // Transfer permissions check1177 let target_collection = Self::get_collection(collection_id)?;1178 ensure!(1179 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1180 (1181 target_collection.limits.owner_can_transfer &&1182 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1183 ),1184 Error::<T>::NoPermission1185 );11861187 if target_collection.access == AccessMode::WhiteList {1188 Self::check_white_list(&target_collection, &sender)?;1189 }11901191 match target_collection.mode1192 {1193 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1194 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1195 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1196 _ => ()1197 };11981199 // call event1200 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12011202 Ok(())1203 }12041205 /// Change ownership of the token.1206 /// 1207 /// # Permissions1208 /// 1209 /// * Collection Owner1210 /// * Collection Admin1211 /// * Current NFT owner1212 ///1213 /// # Arguments1214 /// 1215 /// * recipient: Address of token recipient.1216 /// 1217 /// * collection_id.1218 /// 1219 /// * item_id: ID of the item1220 /// * Non-Fungible Mode: Required.1221 /// * Fungible Mode: Ignored.1222 /// * Re-Fungible Mode: Required.1223 /// 1224 /// * value: Amount to transfer.1225 /// * Non-Fungible Mode: Ignored1226 /// * Fungible Mode: Must specify transferred amount1227 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1228 #[weight = <T as Config>::WeightInfo::transfer()]1229 #[transactional]1230 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1231 let sender = ensure_signed(origin)?;1232 let collection = Self::get_collection(collection_id)?;12331234 Self::transfer_internal(sender, recipient, &collection, item_id, value)1235 }12361237 /// Set, change, or remove approved address to transfer the ownership of the NFT.1238 /// 1239 /// # Permissions1240 /// 1241 /// * Collection Owner1242 /// * Collection Admin1243 /// * Current NFT owner1244 /// 1245 /// # Arguments1246 /// 1247 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1248 /// 1249 /// * collection_id.1250 /// 1251 /// * item_id: ID of the item.1252 #[weight = <T as Config>::WeightInfo::approve()]1253 #[transactional]1254 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12551256 let sender = ensure_signed(origin)?;1257 let target_collection = Self::get_collection(collection_id)?;12581259 Self::token_exists(&target_collection, item_id, &sender)?;12601261 // Transfer permissions check1262 let bypasses_limits = target_collection.limits.owner_can_transfer &&1263 Self::is_owner_or_admin_permissions(1264 &target_collection,1265 sender.clone(),1266 );12671268 let allowance_limit = if bypasses_limits {1269 None1270 } else if let Some(amount) = Self::owned_amount(1271 sender.clone(),1272 &target_collection,1273 item_id,1274 ) {1275 Some(amount)1276 } else {1277 fail!(Error::<T>::NoPermission);1278 };12791280 if target_collection.access == AccessMode::WhiteList {1281 Self::check_white_list(&target_collection, &sender)?;1282 Self::check_white_list(&target_collection, &spender)?;1283 }12841285 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1286 let mut allowance: u128 = amount;1287 if allowance_exists {1288 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1289 }1290 if let Some(limit) = allowance_limit {1291 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1292 }1293 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12941295 Ok(())1296 }1297 1298 /// 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.1299 /// 1300 /// # Permissions1301 /// * Collection Owner1302 /// * Collection Admin1303 /// * Current NFT owner1304 /// * Address approved by current NFT owner1305 /// 1306 /// # Arguments1307 /// 1308 /// * from: Address that owns token.1309 /// 1310 /// * recipient: Address of token recipient.1311 /// 1312 /// * collection_id.1313 /// 1314 /// * item_id: ID of the item.1315 /// 1316 /// * value: Amount to transfer.1317 #[weight = <T as Config>::WeightInfo::transfer_from()]1318 #[transactional]1319 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13201321 let sender = ensure_signed(origin)?;1322 let target_collection = Self::get_collection(collection_id)?;13231324 let mut appoved_transfer = false;13251326 // Check approval1327 let mut approval: u128 = 0;1328 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1329 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1330 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1331 appoved_transfer = true;1332 }13331334 // Limits check1335 Self::is_correct_transfer(&target_collection, &recipient)?;13361337 // Transfer permissions check 1338 ensure!(1339 appoved_transfer || 1340 (1341 target_collection.limits.owner_can_transfer &&1342 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1343 ),1344 Error::<T>::NoPermission1345 );13461347 if target_collection.access == AccessMode::WhiteList {1348 Self::check_white_list(&target_collection, &sender)?;1349 Self::check_white_list(&target_collection, &recipient)?;1350 }13511352 // Reduce approval by transferred amount or remove if remaining approval drops to 01353 if approval.saturating_sub(value) > 0 {1354 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1355 }1356 else {1357 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1358 }13591360 match target_collection.mode1361 {1362 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1363 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1364 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1365 _ => ()1366 };13671368 Ok(())1369 }13701371 // #[weight = 0]1372 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13731374 // // let no_perm_mes = "You do not have permissions to modify this collection";1375 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1376 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1377 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13781379 // // // on_nft_received call13801381 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13821383 // Ok(())1384 // }13851386 /// Set off-chain data schema.1387 /// 1388 /// # Permissions1389 /// 1390 /// * Collection Owner1391 /// * Collection Admin1392 /// 1393 /// # Arguments1394 /// 1395 /// * collection_id.1396 /// 1397 /// * schema: String representing the offchain data schema.1398 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1399 #[transactional]1400 pub fn set_variable_meta_data (1401 origin,1402 collection_id: CollectionId,1403 item_id: TokenId,1404 data: Vec<u8>1405 ) -> DispatchResult {1406 let sender = ensure_signed(origin)?;1407 1408 let target_collection = Self::get_collection(collection_id)?;1409 Self::token_exists(&target_collection, item_id, &sender)?;14101411 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14121413 // Modify permissions check1414 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1415 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1416 Error::<T>::NoPermission);14171418 match target_collection.mode1419 {1420 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1421 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1422 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1423 _ => fail!(Error::<T>::UnexpectedCollectionType)1424 };14251426 Ok(())1427 }1428 1429 /// Set schema standard1430 /// ImageURL1431 /// Unique1432 /// 1433 /// # Permissions1434 /// 1435 /// * Collection Owner1436 /// * Collection Admin1437 /// 1438 /// # Arguments1439 /// 1440 /// * collection_id.1441 /// 1442 /// * schema: SchemaVersion: enum1443 #[weight = <T as Config>::WeightInfo::set_schema_version()]1444 #[transactional]1445 pub fn set_schema_version(1446 origin,1447 collection_id: CollectionId,1448 version: SchemaVersion1449 ) -> DispatchResult {1450 let sender = ensure_signed(origin)?;1451 let mut target_collection = Self::get_collection(collection_id)?;1452 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1453 target_collection.schema_version = version;1454 Self::save_collection(target_collection);14551456 Ok(())1457 }14581459 /// Set off-chain data schema.1460 /// 1461 /// # Permissions1462 /// 1463 /// * Collection Owner1464 /// * Collection Admin1465 /// 1466 /// # Arguments1467 /// 1468 /// * collection_id.1469 /// 1470 /// * schema: String representing the offchain data schema.1471 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1472 #[transactional]1473 pub fn set_offchain_schema(1474 origin,1475 collection_id: CollectionId,1476 schema: Vec<u8>1477 ) -> DispatchResult {1478 let sender = ensure_signed(origin)?;1479 let mut target_collection = Self::get_collection(collection_id)?;1480 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14811482 // check schema limit1483 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14841485 target_collection.offchain_schema = schema;1486 Self::save_collection(target_collection);14871488 Ok(())1489 }14901491 /// Set const on-chain data schema.1492 /// 1493 /// # Permissions1494 /// 1495 /// * Collection Owner1496 /// * Collection Admin1497 /// 1498 /// # Arguments1499 /// 1500 /// * collection_id.1501 /// 1502 /// * schema: String representing the const on-chain data schema.1503 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1504 #[transactional]1505 pub fn set_const_on_chain_schema (1506 origin,1507 collection_id: CollectionId,1508 schema: Vec<u8>1509 ) -> DispatchResult {1510 let sender = ensure_signed(origin)?;1511 let mut target_collection = Self::get_collection(collection_id)?;1512 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15131514 // check schema limit1515 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15161517 target_collection.const_on_chain_schema = schema;1518 Self::save_collection(target_collection);15191520 Ok(())1521 }15221523 /// Set variable on-chain data schema.1524 /// 1525 /// # Permissions1526 /// 1527 /// * Collection Owner1528 /// * Collection Admin1529 /// 1530 /// # Arguments1531 /// 1532 /// * collection_id.1533 /// 1534 /// * schema: String representing the variable on-chain data schema.1535 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1536 #[transactional]1537 pub fn set_variable_on_chain_schema (1538 origin,1539 collection_id: CollectionId,1540 schema: Vec<u8>1541 ) -> DispatchResult {1542 let sender = ensure_signed(origin)?;1543 let mut target_collection = Self::get_collection(collection_id)?;1544 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15451546 // check schema limit1547 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15481549 target_collection.variable_on_chain_schema = schema;1550 Self::save_collection(target_collection);15511552 Ok(())1553 }15541555 // Sudo permissions function1556 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1557 #[transactional]1558 pub fn set_chain_limits(1559 origin,1560 limits: ChainLimits1561 ) -> DispatchResult {15621563 #[cfg(not(feature = "runtime-benchmarks"))]1564 ensure_root(origin)?;15651566 <ChainLimit>::put(limits);1567 Ok(())1568 }15691570 /// Enable smart contract self-sponsoring.1571 /// 1572 /// # Permissions1573 /// 1574 /// * Contract Owner1575 /// 1576 /// # Arguments1577 /// 1578 /// * contract address1579 /// * enable flag1580 /// 1581 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1582 #[transactional]1583 pub fn enable_contract_sponsoring(1584 origin,1585 contract_address: T::AccountId,1586 enable: bool1587 ) -> DispatchResult {15881589 let sender = ensure_signed(origin)?;15901591 #[cfg(feature = "runtime-benchmarks")]1592 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15931594 Self::ensure_contract_owned(sender, &contract_address)?;15951596 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1597 Ok(())1598 }15991600 /// Set the rate limit for contract sponsoring to specified number of blocks.1601 /// 1602 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1603 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1604 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1605 /// from contract endowment if there are at least B blocks between such transactions. 1606 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1607 /// 1608 /// # Permissions1609 /// 1610 /// * Contract Owner1611 /// 1612 /// # Arguments1613 /// 1614 /// -`contract_address`: Address of the contract to sponsor1615 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1616 /// 1617 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1618 #[transactional]1619 pub fn set_contract_sponsoring_rate_limit(1620 origin,1621 contract_address: T::AccountId,1622 rate_limit: T::BlockNumber1623 ) -> DispatchResult {1624 let sender = ensure_signed(origin)?;16251626 #[cfg(feature = "runtime-benchmarks")]1627 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16281629 Self::ensure_contract_owned(sender, &contract_address)?;1630 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1631 Ok(())1632 }16331634 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1635 /// 1636 /// # Permissions1637 /// 1638 /// * Address that deployed smart contract.1639 /// 1640 /// # Arguments1641 /// 1642 /// -`contract_address`: Address of the contract.1643 /// 1644 /// - `enable`: . 1645 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1646 #[transactional]1647 pub fn toggle_contract_white_list(1648 origin,1649 contract_address: T::AccountId,1650 enable: bool1651 ) -> DispatchResult {1652 let sender = ensure_signed(origin)?;16531654 #[cfg(feature = "runtime-benchmarks")]1655 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16561657 Self::ensure_contract_owned(sender, &contract_address)?;1658 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1659 Ok(())1660 }1661 1662 /// Add an address to smart contract white list.1663 /// 1664 /// # Permissions1665 /// 1666 /// * Address that deployed smart contract.1667 /// 1668 /// # Arguments1669 /// 1670 /// -`contract_address`: Address of the contract.1671 ///1672 /// -`account_address`: Address to add.1673 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1674 #[transactional]1675 pub fn add_to_contract_white_list(1676 origin,1677 contract_address: T::AccountId,1678 account_address: T::AccountId1679 ) -> DispatchResult {1680 let sender = ensure_signed(origin)?;16811682 #[cfg(feature = "runtime-benchmarks")]1683 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1684 1685 Self::ensure_contract_owned(sender, &contract_address)?; 1686 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1687 Ok(())1688 }16891690 /// Remove an address from smart contract white list.1691 /// 1692 /// # Permissions1693 /// 1694 /// * Address that deployed smart contract.1695 /// 1696 /// # Arguments1697 /// 1698 /// -`contract_address`: Address of the contract.1699 ///1700 /// -`account_address`: Address to remove.1701 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1702 #[transactional]1703 pub fn remove_from_contract_white_list(1704 origin,1705 contract_address: T::AccountId,1706 account_address: T::AccountId1707 ) -> DispatchResult {1708 let sender = ensure_signed(origin)?;17091710 #[cfg(feature = "runtime-benchmarks")]1711 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17121713 Self::ensure_contract_owned(sender, &contract_address)?;1714 <ContractWhiteList<T>>::remove(contract_address, account_address);1715 Ok(())1716 }17171718 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1719 #[transactional]1720 pub fn set_collection_limits(1721 origin,1722 collection_id: u32,1723 new_limits: CollectionLimits<T::BlockNumber>,1724 ) -> DispatchResult {1725 let sender = ensure_signed(origin)?;1726 let mut target_collection = Self::get_collection(collection_id)?;1727 Self::check_owner_permissions(&target_collection, sender.clone())?;1728 let old_limits = &target_collection.limits;1729 let chain_limits = ChainLimit::get();17301731 // collection bounds1732 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1733 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1734 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1735 Error::<T>::CollectionLimitBoundsExceeded);17361737 // token_limit check prev1738 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1739 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17401741 ensure!(1742 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1743 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1744 Error::<T>::OwnerPermissionsCantBeReverted,1745 );17461747 target_collection.limits = new_limits;1748 Self::save_collection(target_collection);17491750 Ok(())1751 } 1752 }1753}17541755impl<T: Config> Module<T> {17561757 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1758 // Limits check1759 Self::is_correct_transfer(target_collection, &recipient)?;17601761 // Transfer permissions check1762 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1763 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1764 Error::<T>::NoPermission);17651766 if target_collection.access == AccessMode::WhiteList {1767 Self::check_white_list(target_collection, &sender)?;1768 Self::check_white_list(target_collection, &recipient)?;1769 }17701771 match target_collection.mode1772 {1773 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1774 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1775 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1776 _ => ()1777 };17781779 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17801781 Ok(())1782 }178317841785 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1786 let collection_id = collection.id;17871788 // check token limit and account token limit1789 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1790 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1791 1792 Ok(())1793 }17941795 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1796 let collection_id = collection.id;17971798 // check token limit and account token limit1799 let total_items: u32 = ItemListIndex::get(collection_id)1800 .checked_add(amount)1801 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1802 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1803 .checked_add(amount)1804 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1805 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1806 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18071808 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1809 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1810 Self::check_white_list(collection, owner)?;1811 Self::check_white_list(collection, sender)?;1812 }18131814 Ok(())1815 }18161817 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1818 match target_collection.mode1819 {1820 CollectionMode::NFT => {1821 if let CreateItemData::NFT(data) = data {1822 // check sizes1823 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1824 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1825 } else {1826 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1827 }1828 },1829 CollectionMode::Fungible(_) => {1830 if let CreateItemData::Fungible(_) = data {1831 } else {1832 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1833 }1834 },1835 CollectionMode::ReFungible => {1836 if let CreateItemData::ReFungible(data) = data {18371838 // check sizes1839 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1840 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18411842 // Check refungibility limits1843 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1844 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1845 } else {1846 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1847 }1848 },1849 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1850 };18511852 Ok(())1853 }18541855 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1856 match data1857 {1858 CreateItemData::NFT(data) => {1859 let item = NftItemType {1860 owner: owner.clone(),1861 const_data: data.const_data,1862 variable_data: data.variable_data1863 };18641865 Self::add_nft_item(collection, item)?;1866 },1867 CreateItemData::Fungible(data) => {1868 Self::add_fungible_item(collection, &owner, data.value)?;1869 },1870 CreateItemData::ReFungible(data) => {1871 let mut owner_list = Vec::new();1872 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18731874 let item = ReFungibleItemType {1875 owner: owner_list,1876 const_data: data.const_data,1877 variable_data: data.variable_data1878 };18791880 Self::add_refungible_item(collection, item)?;1881 }1882 };18831884 Ok(())1885 }18861887 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1888 let collection_id = collection.id;18891890 // Does new owner already have an account?1891 let mut balance: u128 = 0;1892 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1893 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1894 } 18951896 // Mint 1897 let item = FungibleItemType {1898 value: balance + value1899 };1900 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19011902 // Update balance1903 let new_balance = <Balance<T>>::get(collection_id, owner)1904 .checked_add(value)1905 .ok_or(Error::<T>::NumOverflow)?;1906 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19071908 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1909 Ok(())1910 }19111912 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1913 let collection_id = collection.id;19141915 let current_index = <ItemListIndex>::get(collection_id)1916 .checked_add(1)1917 .ok_or(Error::<T>::NumOverflow)?;1918 let itemcopy = item.clone();19191920 ensure!(1921 item.owner.len() == 1,1922 Error::<T>::BadCreateRefungibleCall,1923 );1924 let item_owner = item.owner.first().expect("only one owner is defined");19251926 let value = item_owner.fraction;1927 let owner = item_owner.owner.clone();19281929 Self::add_token_index(collection_id, current_index, &owner)?;19301931 <ItemListIndex>::insert(collection_id, current_index);1932 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19331934 // Update balance1935 let new_balance = <Balance<T>>::get(collection_id, &owner)1936 .checked_add(value)1937 .ok_or(Error::<T>::NumOverflow)?;1938 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19391940 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1941 Ok(())1942 }19431944 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1945 let collection_id = collection.id;19461947 let current_index = <ItemListIndex>::get(collection_id)1948 .checked_add(1)1949 .ok_or(Error::<T>::NumOverflow)?;19501951 let item_owner = item.owner.clone();1952 Self::add_token_index(collection_id, current_index, &item.owner)?;19531954 <ItemListIndex>::insert(collection_id, current_index);1955 <NftItemList<T>>::insert(collection_id, current_index, item);19561957 // Update balance1958 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1959 .checked_add(1)1960 .ok_or(Error::<T>::NumOverflow)?;1961 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19621963 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1964 Ok(())1965 }19661967 fn burn_refungible_item(1968 collection: &CollectionHandle<T>,1969 item_id: TokenId,1970 owner: &T::AccountId,1971 ) -> DispatchResult {1972 let collection_id = collection.id;19731974 ensure!(1975 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1976 Error::<T>::TokenNotFound1977 );1978 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1979 let rft_balance = token1980 .owner1981 .iter()1982 .find(|&i| i.owner == *owner)1983 .ok_or(Error::<T>::TokenNotFound)?;1984 Self::remove_token_index(collection_id, item_id, owner)?;19851986 // update balance1987 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1988 .checked_sub(rft_balance.fraction)1989 .ok_or(Error::<T>::NumOverflow)?;1990 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19911992 // Re-create owners list with sender removed1993 let index = token1994 .owner1995 .iter()1996 .position(|i| i.owner == *owner)1997 .expect("owned item is exists");1998 token.owner.remove(index);1999 let owner_count = token.owner.len();20002001 // Burn the token completely if this was the last (only) owner2002 if owner_count == 0 {2003 <ReFungibleItemList<T>>::remove(collection_id, item_id);2004 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2005 }2006 else {2007 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2008 }20092010 Ok(())2011 }20122013 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2014 let collection_id = collection.id;20152016 ensure!(2017 <NftItemList<T>>::contains_key(collection_id, item_id),2018 Error::<T>::TokenNotFound2019 );2020 let item = <NftItemList<T>>::get(collection_id, item_id);2021 Self::remove_token_index(collection_id, item_id, &item.owner)?;20222023 // update balance2024 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2025 .checked_sub(1)2026 .ok_or(Error::<T>::NumOverflow)?;2027 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2028 <NftItemList<T>>::remove(collection_id, item_id);2029 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20302031 Ok(())2032 }20332034 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2035 let collection_id = collection.id;20362037 ensure!(2038 <FungibleItemList<T>>::contains_key(collection_id, owner),2039 Error::<T>::TokenNotFound2040 );2041 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2042 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20432044 // update balance2045 let new_balance = <Balance<T>>::get(collection_id, owner)2046 .checked_sub(value)2047 .ok_or(Error::<T>::NumOverflow)?;2048 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20492050 if balance.value - value > 0 {2051 balance.value -= value;2052 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2053 }2054 else {2055 <FungibleItemList<T>>::remove(collection_id, owner);2056 }20572058 Ok(())2059 }20602061 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2062 Ok(<CollectionById<T>>::get(collection_id)2063 .map(|collection| CollectionHandle {2064 id: collection_id,2065 collection2066 })2067 .ok_or(Error::<T>::CollectionNotFound)?)2068 }20692070 fn save_collection(collection: CollectionHandle<T>) {2071 <CollectionById<T>>::insert(collection.id, collection.collection);2072 }20732074 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2075 ensure!(2076 subject == target_collection.owner,2077 Error::<T>::NoPermission2078 );20792080 Ok(())2081 }20822083 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2084 let mut result: bool = subject == collection.owner;2085 let exists = <AdminList<T>>::contains_key(collection.id);20862087 if !result & exists {2088 if <AdminList<T>>::get(collection.id).contains(&subject) {2089 result = true2090 }2091 }20922093 result2094 }20952096 fn check_owner_or_admin_permissions(2097 collection: &CollectionHandle<T>,2098 subject: T::AccountId,2099 ) -> DispatchResult {2100 let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21012102 ensure!(2103 result,2104 Error::<T>::NoPermission2105 );2106 Ok(())2107 }21082109 fn owned_amount(2110 subject: T::AccountId,2111 target_collection: &CollectionHandle<T>,2112 item_id: TokenId,2113 ) -> Option<u128> {2114 let collection_id = target_collection.id;21152116 match target_collection.mode {2117 CollectionMode::NFT => {2118 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2119 return Some(1)2120 }2121 None2122 },2123 CollectionMode::Fungible(_) => {2124 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2125 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2126 .value);2127 }2128 None2129 },2130 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2131 .owner2132 .iter()2133 .find(|i| i.owner == subject)2134 .map(|i| i.fraction),2135 CollectionMode::Invalid => None,2136 }2137 }21382139 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2140 let collection_id = target_collection.id;21412142 match target_collection.mode {2143 CollectionMode::NFT => {2144 <NftItemList<T>>::get(collection_id, item_id).owner == subject2145 }2146 CollectionMode::Fungible(_) => {2147 <FungibleItemList<T>>::contains_key(collection_id, &subject)2148 }2149 CollectionMode::ReFungible => {2150 <ReFungibleItemList<T>>::get(collection_id, item_id)2151 .owner2152 .iter()2153 .any(|i| i.owner == subject)2154 }2155 CollectionMode::Invalid => false,2156 }2157 }21582159 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2160 let collection_id = collection.id;21612162 let mes = Error::<T>::AddresNotInWhiteList;2163 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21642165 Ok(())2166 }21672168 /// Check if token exists. In case of Fungible, check if there is an entry for 2169 /// the owner in fungible balances double map2170 fn token_exists(2171 target_collection: &CollectionHandle<T>,2172 item_id: TokenId,2173 owner: &T::AccountId2174 ) -> DispatchResult {2175 let collection_id = target_collection.id;2176 let exists = match target_collection.mode2177 {2178 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2179 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2180 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2181 _ => false2182 };21832184 ensure!(exists == true, Error::<T>::TokenNotFound);2185 Ok(())2186 }21872188 fn transfer_fungible(2189 collection: &CollectionHandle<T>,2190 value: u128,2191 owner: &T::AccountId,2192 recipient: &T::AccountId,2193 ) -> DispatchResult {2194 let collection_id = collection.id;2195 Self::token_exists(&collection, 0, owner)?;21962197 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2198 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21992200 // Send balance to recipient (updates balanceOf of recipient)2201 Self::add_fungible_item(collection, recipient, value)?;22022203 // update balanceOf of sender2204 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22052206 // Reduce or remove sender2207 if balance.value == value {2208 <FungibleItemList<T>>::remove(collection_id, owner);2209 }2210 else {2211 balance.value -= value;2212 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2213 }22142215 Ok(())2216 }22172218 fn transfer_refungible(2219 collection: &CollectionHandle<T>,2220 item_id: TokenId,2221 value: u128,2222 owner: T::AccountId,2223 new_owner: T::AccountId,2224 ) -> DispatchResult {2225 let collection_id = collection.id;2226 Self::token_exists(collection, item_id, &owner)?;22272228 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2229 let item = full_item2230 .owner2231 .iter()2232 .filter(|i| i.owner == owner)2233 .next()2234 .ok_or(Error::<T>::TokenNotFound)?;2235 let amount = item.fraction;22362237 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22382239 // update balance2240 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2241 .checked_sub(value)2242 .ok_or(Error::<T>::NumOverflow)?;2243 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22442245 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2246 .checked_add(value)2247 .ok_or(Error::<T>::NumOverflow)?;2248 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22492250 let old_owner = item.owner.clone();2251 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22522253 // transfer2254 if amount == value && !new_owner_has_account {2255 // change owner2256 // new owner do not have account2257 let mut new_full_item = full_item.clone();2258 new_full_item2259 .owner2260 .iter_mut()2261 .find(|i| i.owner == owner)2262 .expect("old owner does present in refungible")2263 .owner = new_owner.clone();2264 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22652266 // update index collection2267 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2268 } else {2269 let mut new_full_item = full_item.clone();2270 new_full_item2271 .owner2272 .iter_mut()2273 .find(|i| i.owner == owner)2274 .expect("old owner does present in refungible")2275 .fraction -= value;22762277 // separate amount2278 if new_owner_has_account {2279 // new owner has account2280 new_full_item2281 .owner2282 .iter_mut()2283 .find(|i| i.owner == new_owner)2284 .expect("new owner has account")2285 .fraction += value;2286 } else {2287 // new owner do not have account2288 new_full_item.owner.push(Ownership {2289 owner: new_owner.clone(),2290 fraction: value,2291 });2292 Self::add_token_index(collection_id, item_id, &new_owner)?;2293 }22942295 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2296 }22972298 Ok(())2299 }23002301 fn transfer_nft(2302 collection: &CollectionHandle<T>,2303 item_id: TokenId,2304 sender: T::AccountId,2305 new_owner: T::AccountId,2306 ) -> DispatchResult {2307 let collection_id = collection.id;2308 Self::token_exists(&collection, item_id, &sender)?;23092310 let mut item = <NftItemList<T>>::get(collection_id, item_id);23112312 ensure!(2313 sender == item.owner,2314 Error::<T>::MustBeTokenOwner2315 );23162317 // update balance2318 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2319 .checked_sub(1)2320 .ok_or(Error::<T>::NumOverflow)?;2321 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23222323 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2324 .checked_add(1)2325 .ok_or(Error::<T>::NumOverflow)?;2326 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23272328 // change owner2329 let old_owner = item.owner.clone();2330 item.owner = new_owner.clone();2331 <NftItemList<T>>::insert(collection_id, item_id, item);23322333 // update index collection2334 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23352336 Ok(())2337 }2338 2339 fn set_re_fungible_variable_data(2340 collection: &CollectionHandle<T>,2341 item_id: TokenId,2342 data: Vec<u8>2343 ) -> DispatchResult {2344 let collection_id = collection.id;2345 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23462347 item.variable_data = data;23482349 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23502351 Ok(())2352 }23532354 fn set_nft_variable_data(2355 collection: &CollectionHandle<T>,2356 item_id: TokenId,2357 data: Vec<u8>2358 ) -> DispatchResult {2359 let collection_id = collection.id;2360 let mut item = <NftItemList<T>>::get(collection_id, item_id);2361 2362 item.variable_data = data;23632364 <NftItemList<T>>::insert(collection_id, item_id, item);2365 2366 Ok(())2367 }23682369 fn init_collection(item: &Collection<T>) {2370 // check params2371 assert!(2372 item.decimal_points <= MAX_DECIMAL_POINTS,2373 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2374 );2375 assert!(2376 item.name.len() <= 64,2377 "Collection name can not be longer than 63 char"2378 );2379 assert!(2380 item.name.len() <= 256,2381 "Collection description can not be longer than 255 char"2382 );2383 assert!(2384 item.token_prefix.len() <= 16,2385 "Token prefix can not be longer than 15 char"2386 );23872388 // Generate next collection ID2389 let next_id = CreatedCollectionCount::get()2390 .checked_add(1)2391 .unwrap();23922393 CreatedCollectionCount::put(next_id);2394 }23952396 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2397 let current_index = <ItemListIndex>::get(collection_id)2398 .checked_add(1)2399 .unwrap();24002401 let item_owner = item.owner.clone();2402 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24032404 <ItemListIndex>::insert(collection_id, current_index);24052406 // Update balance2407 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2408 .checked_add(1)2409 .unwrap();2410 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2411 }24122413 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2414 let current_index = <ItemListIndex>::get(collection_id)2415 .checked_add(1)2416 .unwrap();24172418 Self::add_token_index(collection_id, current_index, owner).unwrap();24192420 <ItemListIndex>::insert(collection_id, current_index);24212422 // Update balance2423 let new_balance = <Balance<T>>::get(collection_id, owner)2424 .checked_add(item.value)2425 .unwrap();2426 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2427 }24282429 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2430 let current_index = <ItemListIndex>::get(collection_id)2431 .checked_add(1)2432 .unwrap();24332434 let value = item.owner.first().unwrap().fraction;2435 let owner = item.owner.first().unwrap().owner.clone();24362437 Self::add_token_index(collection_id, current_index, &owner).unwrap();24382439 <ItemListIndex>::insert(collection_id, current_index);24402441 // Update balance2442 let new_balance = <Balance<T>>::get(collection_id, &owner)2443 .checked_add(value)2444 .unwrap();2445 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2446 }24472448 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2449 // add to account limit2450 if <AccountItemCount<T>>::contains_key(owner) {24512452 // bound Owned tokens by a single address2453 let count = <AccountItemCount<T>>::get(owner);2454 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24552456 <AccountItemCount<T>>::insert(owner.clone(), count2457 .checked_add(1)2458 .ok_or(Error::<T>::NumOverflow)?);2459 }2460 else {2461 <AccountItemCount<T>>::insert(owner.clone(), 1);2462 }24632464 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2465 if list_exists {2466 let mut list = <AddressTokens<T>>::get(collection_id, owner);2467 let item_contains = list.contains(&item_index.clone());24682469 if !item_contains {2470 list.push(item_index.clone());2471 }24722473 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2474 } else {2475 let mut itm = Vec::new();2476 itm.push(item_index.clone());2477 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2478 }24792480 Ok(())2481 }24822483 fn remove_token_index(2484 collection_id: CollectionId,2485 item_index: TokenId,2486 owner: &T::AccountId,2487 ) -> DispatchResult {24882489 // update counter2490 <AccountItemCount<T>>::insert(owner.clone(), 2491 <AccountItemCount<T>>::get(owner)2492 .checked_sub(1)2493 .ok_or(Error::<T>::NumOverflow)?);249424952496 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2497 if list_exists {2498 let mut list = <AddressTokens<T>>::get(collection_id, owner);2499 let item_contains = list.contains(&item_index.clone());25002501 if item_contains {2502 list.retain(|&item| item != item_index);2503 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2504 }2505 }25062507 Ok(())2508 }25092510 fn move_token_index(2511 collection_id: CollectionId,2512 item_index: TokenId,2513 old_owner: &T::AccountId,2514 new_owner: &T::AccountId,2515 ) -> DispatchResult {2516 Self::remove_token_index(collection_id, item_index, old_owner)?;2517 Self::add_token_index(collection_id, item_index, new_owner)?;25182519 Ok(())2520 }2521 2522 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2523 if <ContractOwner<T>>::contains_key(contract.clone()) {2524 let owner = <ContractOwner<T>>::get(contract);2525 ensure!(account == owner, Error::<T>::NoPermission);2526 } else {2527 fail!(Error::<T>::NoPermission);2528 }25292530 Ok(())2531 }2532}25332534////////////////////////////////////////////////////////////////////////////////////////////////////2535// Economic models2536// #region25372538/// Fee multiplier.2539pub type Multiplier = FixedU128;25402541type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25422543/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2544/// in the queue.2545#[derive(Encode, Decode, Clone, Eq, PartialEq)]2546pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25472548impl<T: Config + Send + Sync> sp_std::fmt::Debug 2549 for ChargeTransactionPayment<T>2550{2551 #[cfg(feature = "std")]2552 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2553 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2554 }2555 #[cfg(not(feature = "std"))]2556 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2557 Ok(())2558 }2559}25602561impl<T: Config> ChargeTransactionPayment<T>2562where2563 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2564 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2565 T::AccountId: AsRef<[u8]>,2566 T::AccountId: UncheckedFrom<T::Hash>,2567{2568 fn traditional_fee(2569 len: usize,2570 info: &DispatchInfoOf<T::Call>,2571 tip: BalanceOf<T>,2572 ) -> BalanceOf<T>2573 where2574 T::Call: Dispatchable<Info = DispatchInfo>,2575 {2576 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2577 }25782579 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2580 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2581 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2582 let len_saturation = max_block_length as u64 / (len as u64).max(1);2583 let coefficient: BalanceOf<T> = weight_saturation2584 .min(len_saturation)2585 .saturated_into::<BalanceOf<T>>();2586 final_fee2587 .saturating_mul(coefficient)2588 .saturated_into::<TransactionPriority>()2589 }25902591 fn withdraw_fee(2592 &self,2593 who: &T::AccountId,2594 call: &T::Call,2595 info: &DispatchInfoOf<T::Call>,2596 len: usize,2597 ) -> Result<2598 (2599 BalanceOf<T>,2600 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2601 ),2602 TransactionValidityError,2603 > {2604 let tip = self.0;26052606 let fee = Self::traditional_fee(len, info, tip);26072608 // Only mess with balances if fee is not zero.2609 if fee.is_zero() {2610 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2611 .map(|i| (fee, i));2612 }26132614 // Determine who is paying transaction fee based on ecnomic model2615 // Parse call to extract collection ID and access collection sponsor2616 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2617 Some(Call::create_item(collection_id, _owner, _properties)) => {2618 let collection = <CollectionById<T>>::get(collection_id)?;26192620 // sponsor timeout2621 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26222623 let limit = collection.limits.sponsor_transfer_timeout;2624 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2625 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2626 let limit_time = last_tx_block + limit.into();2627 if block_number <= limit_time {2628 return None;2629 }2630 }2631 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26322633 // check free create limit2634 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2635 collection.sponsorship.sponsor()2636 .cloned()2637 } else {2638 None2639 }2640 }2641 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2642 let collection = <CollectionById<T>>::get(collection_id)?;2643 2644 let mut sponsor_transfer = false;2645 if collection.sponsorship.confirmed() {26462647 let collection_limits = collection.limits;2648 let collection_mode = collection.mode;2649 2650 // sponsor timeout2651 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2652 sponsor_transfer = match collection_mode {2653 CollectionMode::NFT => {2654 2655 // get correct limit2656 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2657 collection_limits.sponsor_transfer_timeout2658 } else {2659 ChainLimit::get().nft_sponsor_transfer_timeout2660 };2661 2662 let mut sponsored = true;2663 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2664 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2665 let limit_time = last_tx_block + limit.into();2666 if block_number <= limit_time {2667 sponsored = false;2668 }2669 }2670 if sponsored {2671 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2672 }26732674 sponsored2675 }2676 CollectionMode::Fungible(_) => {2677 2678 // get correct limit2679 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2680 collection_limits.sponsor_transfer_timeout2681 } else {2682 ChainLimit::get().fungible_sponsor_transfer_timeout2683 };2684 2685 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2686 let mut sponsored = true;2687 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2688 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2689 let limit_time = last_tx_block + limit.into();2690 if block_number <= limit_time {2691 sponsored = false;2692 }2693 }2694 if sponsored {2695 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2696 }26972698 sponsored2699 }2700 CollectionMode::ReFungible => {2701 2702 // get correct limit2703 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2704 collection_limits.sponsor_transfer_timeout2705 } else {2706 ChainLimit::get().refungible_sponsor_transfer_timeout2707 };2708 2709 let mut sponsored = true;2710 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2711 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2712 let limit_time = last_tx_block + limit.into();2713 if block_number <= limit_time {2714 sponsored = false;2715 }2716 }2717 if sponsored {2718 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2719 }27202721 sponsored2722 }2723 _ => {2724 false2725 },2726 };2727 }27282729 if !sponsor_transfer {2730 None2731 } else {2732 collection.sponsorship.sponsor()2733 .cloned()2734 }2735 }27362737 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2738 let mut sponsor_metadata_changes = false;27392740 let collection = <CollectionById<T>>::get(collection_id)?;27412742 if2743 collection.sponsorship.confirmed() &&2744 // Can't sponsor fungible collection, this tx will be rejected2745 // as invalid2746 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2747 data.len() <= collection.limits.sponsored_data_size as usize2748 {2749 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2750 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27512752 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2753 .map(|last_block| block_number - last_block > rate_limit)2754 .unwrap_or(true) 2755 {2756 sponsor_metadata_changes = true;2757 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2758 }2759 }2760 }27612762 if !sponsor_metadata_changes {2763 None2764 } else {2765 collection.sponsorship.sponsor().cloned()2766 }2767 }27682769 _ => None,2770 })();27712772 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2773 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27742775 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27762777 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2778 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2779 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2780 2781 if !owned_contract && white_list_enabled {2782 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2783 return Err(InvalidTransaction::Call.into());2784 }2785 }2786 },2787 _ => {},2788 }27892790 // Sponsor smart contracts2791 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27922793 // On instantiation: set the contract owner2794 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27952796 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2797 &who,2798 code_hash,2799 salt,2800 );2801 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28022803 None2804 },28052806 // On instantiation with code: set the contract owner2807 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28082809 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2810 &who,2811 &T::Hashing::hash(&_code),2812 _salt,2813 );28142815 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28162817 None2818 }28192820 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2821 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28222823 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28242825 let mut sponsor_transfer = false;2826 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2827 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2828 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2829 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2830 let limit_time = last_tx_block + rate_limit;28312832 if block_number >= limit_time {2833 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2834 sponsor_transfer = true;2835 }2836 } else {2837 sponsor_transfer = false;2838 }2839 2840 if sponsor_transfer {2841 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2842 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2843 return Some(called_contract);2844 }2845 }2846 }28472848 None2849 },28502851 _ => None,2852 });28532854 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28552856 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2857 .map(|i| (fee, i))2858 }2859}286028612862impl<T: Config + Send + Sync> SignedExtension2863 for ChargeTransactionPayment<T>2864where2865 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2866 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2867 T::AccountId: AsRef<[u8]>,2868 T::AccountId: UncheckedFrom<T::Hash>,2869{2870 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2871 type AccountId = T::AccountId;2872 type Call = T::Call;2873 type AdditionalSigned = ();2874 type Pre = (2875 // tip2876 BalanceOf<T>,2877 // who pays fee2878 Self::AccountId,2879 // imbalance resulting from withdrawing the fee2880 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2881 );2882 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2883 Ok(())2884 }28852886 fn validate(2887 &self,2888 who: &Self::AccountId,2889 call: &Self::Call,2890 info: &DispatchInfoOf<Self::Call>,2891 len: usize,2892 ) -> TransactionValidity {2893 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2894 Ok(ValidTransaction {2895 priority: Self::get_priority(len, info, fee),2896 ..Default::default()2897 })2898 }28992900 fn pre_dispatch(2901 self,2902 who: &Self::AccountId,2903 call: &Self::Call,2904 info: &DispatchInfoOf<Self::Call>,2905 len: usize,2906 ) -> Result<Self::Pre, TransactionValidityError> {2907 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2908 Ok((self.0, who.clone(), imbalance))2909 }29102911 fn post_dispatch(2912 pre: Self::Pre,2913 info: &DispatchInfoOf<Self::Call>,2914 post_info: &PostDispatchInfoOf<Self::Call>,2915 len: usize,2916 _result: &DispatchResult,2917 ) -> Result<(), TransactionValidityError> {2918 let (tip, who, imbalance) = pre;2919 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2920 len as u32,2921 info,2922 post_info,2923 tip,2924 );2925 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2926 Ok(())2927 }2928}29292930// #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 core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue,32 transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38 traits::{39 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40 },41 transaction_validity::{42 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43 },44 FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263// Structs64// #region6566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73 Invalid,74 NFT,75 // decimal points76 Fungible(DecimalPoints),77 ReFungible,78}7980impl Default for CollectionMode {81 fn default() -> Self {82 Self::Invalid83 }84}8586impl Into<u8> for CollectionMode {87 fn into(self) -> u8 {88 match self {89 CollectionMode::Invalid => 0,90 CollectionMode::NFT => 1,91 CollectionMode::Fungible(_) => 2,92 CollectionMode::ReFungible => 3,93 }94 }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100 Normal,101 WhiteList,102}103impl Default for AccessMode {104 fn default() -> Self {105 Self::Normal106 }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112 ImageURL,113 Unique,114}115impl Default for SchemaVersion {116 fn default() -> Self {117 Self::ImageURL118 }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124 pub owner: AccountId,125 pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131 /// The fees are applied to the transaction sender132 Disabled,133 Unconfirmed(AccountId),134 /// Transactions are sponsored by specified account135 Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139 fn sponsor(&self) -> Option<&AccountId> {140 match self {141 Self::Confirmed(sponsor) => Some(sponsor),142 _ => None,143 }144 }145146 fn pending_sponsor(&self) -> Option<&AccountId> {147 match self {148 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149 _ => None,150 }151 }152153 fn confirmed(&self) -> bool {154 matches!(self, Self::Confirmed(_))155 }156}157158impl<T> Default for SponsorshipState<T> {159 fn default() -> Self {160 Self::Disabled161 }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167 pub owner: T::AccountId,168 pub mode: CollectionMode,169 pub access: AccessMode,170 pub decimal_points: DecimalPoints,171 pub name: Vec<u16>, // 64 include null escape char172 pub description: Vec<u16>, // 256 include null escape char173 pub token_prefix: Vec<u8>, // 16 include null escape char174 pub mint_mode: bool,175 pub offchain_schema: Vec<u8>,176 pub schema_version: SchemaVersion,177 pub sponsorship: SponsorshipState<T::AccountId>,178 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 179 pub variable_on_chain_schema: Vec<u8>, //180 pub const_on_chain_schema: Vec<u8>, //181}182183pub struct CollectionHandle<T: Config> {184 pub id: CollectionId,185 collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189 type Target = Collection<T>;190191 fn deref(&self) -> &Self::Target {192 &self.collection193 }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197 fn deref_mut(&mut self) -> &mut Self::Target {198 &mut self.collection199 }200}201202#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205 pub owner: AccountId,206 pub const_data: Vec<u8>,207 pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213 pub value: u128,214}215216#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219 pub owner: Vec<Ownership<AccountId>>,220 pub const_data: Vec<u8>,221 pub variable_data: Vec<u8>,222}223224// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]225// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]226// pub struct VestingItem<AccountId, Moment> {227// pub sender: AccountId,228// pub recipient: AccountId,229// pub collection_id: CollectionId,230// pub item_id: TokenId,231// pub amount: u64,232// pub vesting_date: Moment,233// }234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238 pub account_token_ownership_limit: u32,239 pub sponsored_data_size: u32,240 /// None - setVariableMetadata is not sponsored241 /// Some(v) - setVariableMetadata is sponsored 242 /// if there is v block between txs243 pub sponsored_data_rate_limit: Option<BlockNumber>,244 pub token_limit: u32,245246 // Timeouts for item types in passed blocks247 pub sponsor_transfer_timeout: u32,248 pub owner_can_transfer: bool,249 pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253 fn default() -> Self {254 Self { 255 account_token_ownership_limit: 10_000_000, 256 token_limit: u32::max_value(),257 sponsored_data_size: u32::MAX, 258 sponsored_data_rate_limit: None,259 sponsor_transfer_timeout: 14400,260 owner_can_transfer: true,261 owner_can_destroy: true262 }263 }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269 pub collection_numbers_limit: u32,270 pub account_token_ownership_limit: u32,271 pub collections_admins_limit: u64,272 pub custom_data_limit: u32,273274 // Timeouts for item types in passed blocks275 pub nft_sponsor_transfer_timeout: u32,276 pub fungible_sponsor_transfer_timeout: u32,277 pub refungible_sponsor_transfer_timeout: u32,278279 // Schema limits280 pub offchain_schema_limit: u32,281 pub variable_on_chain_schema_limit: u32,282 pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286 fn create_collection() -> Weight;287 fn destroy_collection() -> Weight;288 fn add_to_white_list() -> Weight;289 fn remove_from_white_list() -> Weight;290 fn set_public_access_mode() -> Weight;291 fn set_mint_permission() -> Weight;292 fn change_collection_owner() -> Weight;293 fn add_collection_admin() -> Weight;294 fn remove_collection_admin() -> Weight;295 fn set_collection_sponsor() -> Weight;296 fn confirm_sponsorship() -> Weight;297 fn remove_collection_sponsor() -> Weight;298 fn create_item(s: usize) -> Weight;299 fn burn_item() -> Weight;300 fn transfer() -> Weight;301 fn approve() -> Weight;302 fn transfer_from() -> Weight;303 fn set_offchain_schema() -> Weight;304 fn set_const_on_chain_schema() -> Weight;305 fn set_variable_on_chain_schema() -> Weight;306 fn set_variable_meta_data() -> Weight;307 fn enable_contract_sponsoring() -> Weight;308 fn set_schema_version() -> Weight;309 fn set_chain_limits() -> Weight;310 fn set_contract_sponsoring_rate_limit() -> Weight;311 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312 fn toggle_contract_white_list() -> Weight;313 fn add_to_contract_white_list() -> Weight;314 fn remove_from_contract_white_list() -> Weight;315 fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321 pub const_data: Vec<u8>,322 pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328 pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334 pub const_data: Vec<u8>,335 pub variable_data: Vec<u8>,336 pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342 NFT(CreateNftData),343 Fungible(CreateFungibleData),344 ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348 pub fn len(&self) -> usize {349 let len = match self {350 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352 _ => 0353 };354 355 return len;356 }357}358359impl From<CreateNftData> for CreateItemData {360 fn from(item: CreateNftData) -> Self {361 CreateItemData::NFT(item)362 }363}364365impl From<CreateReFungibleData> for CreateItemData {366 fn from(item: CreateReFungibleData) -> Self {367 CreateItemData::ReFungible(item)368 }369}370371impl From<CreateFungibleData> for CreateItemData {372 fn from(item: CreateFungibleData) -> Self {373 CreateItemData::Fungible(item)374 }375}376377378decl_error! {379 /// Error for non-fungible-token module.380 pub enum Error for Module<T: Config> {381 /// Total collections bound exceeded.382 TotalCollectionsLimitExceeded,383 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.384 CollectionDecimalPointLimitExceeded, 385 /// Collection name can not be longer than 63 char.386 CollectionNameLimitExceeded, 387 /// Collection description can not be longer than 255 char.388 CollectionDescriptionLimitExceeded, 389 /// Token prefix can not be longer than 15 char.390 CollectionTokenPrefixLimitExceeded,391 /// This collection does not exist.392 CollectionNotFound,393 /// Item not exists.394 TokenNotFound,395 /// Admin not found396 AdminNotFound,397 /// Arithmetic calculation overflow.398 NumOverflow, 399 /// Account already has admin role.400 AlreadyAdmin, 401 /// You do not own this collection.402 NoPermission,403 /// This address is not set as sponsor, use setCollectionSponsor first.404 ConfirmUnsetSponsorFail,405 /// Collection is not in mint mode.406 PublicMintingNotAllowed,407 /// Sender parameter and item owner must be equal.408 MustBeTokenOwner,409 /// Item balance not enough.410 TokenValueTooLow,411 /// Size of item is too large.412 NftSizeLimitExceeded,413 /// No approve found414 ApproveNotFound,415 /// Requested value more than approved.416 TokenValueNotEnough,417 /// Only approved addresses can call this method.418 ApproveRequired,419 /// Address is not in white list.420 AddresNotInWhiteList,421 /// Number of collection admins bound exceeded.422 CollectionAdminsLimitExceeded,423 /// Owned tokens by a single address bound exceeded.424 AddressOwnershipLimitExceeded,425 /// Length of items properties must be greater than 0.426 EmptyArgument,427 /// const_data exceeded data limit.428 TokenConstDataLimitExceeded,429 /// variable_data exceeded data limit.430 TokenVariableDataLimitExceeded,431 /// Not NFT item data used to mint in NFT collection.432 NotNftDataUsedToMintNftCollectionToken,433 /// Not Fungible item data used to mint in Fungible collection.434 NotFungibleDataUsedToMintFungibleCollectionToken,435 /// Not Re Fungible item data used to mint in Re Fungible collection.436 NotReFungibleDataUsedToMintReFungibleCollectionToken,437 /// Unexpected collection type.438 UnexpectedCollectionType,439 /// Can't store metadata in fungible tokens.440 CantStoreMetadataInFungibleTokens,441 /// Collection token limit exceeded442 CollectionTokenLimitExceeded,443 /// Account token limit exceeded per collection444 AccountTokenLimitExceeded,445 /// Collection limit bounds per collection exceeded446 CollectionLimitBoundsExceeded,447 /// Tried to enable permissions which are only permitted to be disabled448 OwnerPermissionsCantBeReverted,449 /// Schema data size limit bound exceeded450 SchemaDataLimitExceeded,451 /// Maximum refungibility exceeded452 WrongRefungiblePieces,453 /// createRefungible should be called with one owner454 BadCreateRefungibleCall,455 }456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461 /// Weight information for extrinsics in this pallet.462 type WeightInfo: WeightInfo;463464 type Currency: Currency<Self::AccountId>;465 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466 type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472// #endregion473474// # Used definitions475//476// ## User control levels477//478// chain-controlled - key is uncontrolled by user479// i.e autoincrementing index480// can use non-cryptographic hash481// real - key is controlled by user482// but it is hard to generate enough colliding values, i.e owner of signed txs483// can use non-cryptographic hash484// controlled - key is completly controlled by users485// i.e maps with mutable keys486// should use cryptographic hash487//488// ## User control level downgrade reasons489//490// ?1 - chain-controlled -> controlled491// collections/tokens can be destroyed, resulting in massive holes492// ?2 - chain-controlled -> controlled493// same as ?1, but can be only added, resulting in easier exploitation494// ?3 - real -> controlled495// no confirmation required, so addresses can be easily generated496decl_storage! {497 trait Store for Module<T: Config> as Nft {498499 //#region Private members500 /// Id of next collection501 CreatedCollectionCount: u32;502 /// Used for migrations503 ChainVersion: u64;504 /// Id of last collection token505 /// Collection id (controlled?1)506 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507 //#endregion508509 //#region Chain limits struct510 pub ChainLimit get(fn chain_limit) config(): ChainLimits;511 //#endregion512513 //#region Bound counters514 /// Amount of collections destroyed, used for total amount tracking with515 /// CreatedCollectionCount516 DestroyedCollectionCount: u32;517 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)518 /// Account id (real)519 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520 //#endregion521522 //#region Basic collections523 /// Collection info524 /// Collection id (controlled?1)525 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526 /// List of collection admins527 /// Collection id (controlled?2)528 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529 /// Whitelisted collection users530 /// Collection id (controlled?2), user id (controlled?3)531 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532 //#endregion533534 /// How many of collection items user have535 /// Collection id (controlled?2), account id (real)536 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538 /// Amount of items which spender can transfer out of owners account (via transferFrom)539 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))540 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;541542 //#region Item collections543 /// Collection id (controlled?2), token id (controlled?1)544 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => NftItemType<T::AccountId>;545 /// Collection id (controlled?2), owner (controlled?2)546 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;547 /// Collection id (controlled?2), token id (controlled?1)548 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => ReFungibleItemType<T::AccountId>;549 //#endregion550551 //#region Index list552 /// Collection id (controlled?2), tokens owner (controlled?2)553 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;554 //#endregion555556 //#region Tokens transfer rate limit baskets557 /// (Collection id (controlled?2), who created (real))558 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;559 /// Collection id (controlled?2), token id (controlled?2)560 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;561 /// Collection id (controlled?2), owning user (real)562 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;563 /// Collection id (controlled?2), token id (controlled?2)564 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;565 //#endregion566567 /// Variable metadata sponsoring568 /// Collection id (controlled?2), token id (controlled?2)569 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;570 571 //#region Contract Sponsorship and Ownership572 /// Contract address (real)573 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => T::AccountId;574 /// Contract address (real)575 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;576 /// (Contract address(real), caller (real))577 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;578 /// Contract address (real)579 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;580 /// Contract address (real)581 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 582 /// Contract address (real) => Whitelisted user (controlled?3)583 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 584 //#endregion585 }586 add_extra_genesis {587 build(|config: &GenesisConfig<T>| {588 // Modification of storage589 for (_num, _c) in &config.collection_id {590 <Module<T>>::init_collection(_c);591 }592593 for (_num, _c, _i) in &config.nft_item_id {594 <Module<T>>::init_nft_token(*_c, _i);595 }596597 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {598 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);599 }600601 for (_num, _c, _i) in &config.refungible_item_id {602 <Module<T>>::init_refungible_token(*_c, _i);603 }604 })605 }606}607608decl_event!(609 pub enum Event<T>610 where611 AccountId = <T as system::Config>::AccountId,612 {613 /// New collection was created614 /// 615 /// # Arguments616 /// 617 /// * collection_id: Globally unique identifier of newly created collection.618 /// 619 /// * mode: [CollectionMode] converted into u8.620 /// 621 /// * account_id: Collection owner.622 Created(CollectionId, u8, AccountId),623624 /// New item was created.625 /// 626 /// # Arguments627 /// 628 /// * collection_id: Id of the collection where item was created.629 /// 630 /// * item_id: Id of an item. Unique within the collection.631 ///632 /// * recipient: Owner of newly created item 633 ItemCreated(CollectionId, TokenId, AccountId),634635 /// Collection item was burned.636 /// 637 /// # Arguments638 /// 639 /// collection_id.640 /// 641 /// item_id: Identifier of burned NFT.642 ItemDestroyed(CollectionId, TokenId),643644 /// Item was transferred645 ///646 /// * collection_id: Id of collection to which item is belong647 ///648 /// * item_id: Id of an item649 ///650 /// * sender: Original owner of item651 ///652 /// * recipient: New owner of item653 ///654 /// * amount: Always 1 for NFT655 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),656657 /// * collection_id658 ///659 /// * item_id660 ///661 /// * sender662 ///663 /// * spender664 ///665 /// * amount666 Approved(CollectionId, TokenId, AccountId, AccountId, u128),667 }668);669670decl_module! {671 pub struct Module<T: Config> for enum Call 672 where 673 origin: T::Origin674 {675 fn deposit_event() = default;676 type Error = Error<T>;677678 fn on_initialize(now: T::BlockNumber) -> Weight {679 0680 }681682 /// 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.683 /// 684 /// # Permissions685 /// 686 /// * Anyone.687 /// 688 /// # Arguments689 /// 690 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.691 /// 692 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.693 /// 694 /// * token_prefix: UTF-8 string with token prefix.695 /// 696 /// * mode: [CollectionMode] collection type and type dependent data.697 // returns collection ID698 #[weight = <T as Config>::WeightInfo::create_collection()]699 #[transactional]700 pub fn create_collection(origin,701 collection_name: Vec<u16>,702 collection_description: Vec<u16>,703 token_prefix: Vec<u8>,704 mode: CollectionMode) -> DispatchResult {705706 // Anyone can create a collection707 let who = ensure_signed(origin)?;708709 // Take a (non-refundable) deposit of collection creation710 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();711 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(712 &T::TreasuryAccountId::get(),713 T::CollectionCreationPrice::get(),714 ));715 <T as Config>::Currency::settle(716 &who,717 imbalance,718 WithdrawReasons::TRANSFER,719 ExistenceRequirement::KeepAlive,720 ).map_err(|_| Error::<T>::NoPermission)?;721722 let decimal_points = match mode {723 CollectionMode::Fungible(points) => points,724 _ => 0725 };726727 let chain_limit = ChainLimit::get();728729 let created_count = CreatedCollectionCount::get();730 let destroyed_count = DestroyedCollectionCount::get();731732 // bound Total number of collections733 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);734735 // check params736 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);737 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);738 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);739 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);740741 // Generate next collection ID742 let next_id = created_count743 .checked_add(1)744 .ok_or(Error::<T>::NumOverflow)?;745746 CreatedCollectionCount::put(next_id);747748 let limits = CollectionLimits {749 sponsored_data_size: chain_limit.custom_data_limit,750 ..Default::default()751 };752753 // Create new collection754 let new_collection = Collection {755 owner: who.clone(),756 name: collection_name,757 mode: mode.clone(),758 mint_mode: false,759 access: AccessMode::Normal,760 description: collection_description,761 decimal_points: decimal_points,762 token_prefix: token_prefix,763 offchain_schema: Vec::new(),764 schema_version: SchemaVersion::ImageURL,765 sponsorship: SponsorshipState::Disabled,766 variable_on_chain_schema: Vec::new(),767 const_on_chain_schema: Vec::new(),768 limits,769 };770771 // Add new collection to map772 <CollectionById<T>>::insert(next_id, new_collection);773774 // call event775 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));776777 Ok(())778 }779780 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.781 /// 782 /// # Permissions783 /// 784 /// * Collection Owner.785 /// 786 /// # Arguments787 /// 788 /// * collection_id: collection to destroy.789 #[weight = <T as Config>::WeightInfo::destroy_collection()]790 #[transactional]791 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {792793 let sender = ensure_signed(origin)?;794 let collection = Self::get_collection(collection_id)?;795 Self::check_owner_permissions(&collection, sender)?;796 if !collection.limits.owner_can_destroy {797 fail!(Error::<T>::NoPermission);798 }799800 <AddressTokens<T>>::remove_prefix(collection_id);801 <Allowances<T>>::remove_prefix(collection_id);802 <Balance<T>>::remove_prefix(collection_id);803 <ItemListIndex>::remove(collection_id);804 <AdminList<T>>::remove(collection_id);805 <CollectionById<T>>::remove(collection_id);806 <WhiteList<T>>::remove_prefix(collection_id);807808 <NftItemList<T>>::remove_prefix(collection_id);809 <FungibleItemList<T>>::remove_prefix(collection_id);810 <ReFungibleItemList<T>>::remove_prefix(collection_id);811812 <NftTransferBasket<T>>::remove_prefix(collection_id);813 <FungibleTransferBasket<T>>::remove_prefix(collection_id);814 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);815816 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);817818 DestroyedCollectionCount::put(DestroyedCollectionCount::get()819 .checked_add(1)820 .ok_or(Error::<T>::NumOverflow)?);821822 Ok(())823 }824825 /// Add an address to white list.826 /// 827 /// # Permissions828 /// 829 /// * Collection Owner830 /// * Collection Admin831 /// 832 /// # Arguments833 /// 834 /// * collection_id.835 /// 836 /// * address.837 #[weight = <T as Config>::WeightInfo::add_to_white_list()]838 #[transactional]839 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{840841 let sender = ensure_signed(origin)?;842 let collection = Self::get_collection(collection_id)?;843 Self::check_owner_or_admin_permissions(&collection, sender)?;844845 <WhiteList<T>>::insert(collection_id, address, true);846 847 Ok(())848 }849850 /// Remove an address from white list.851 /// 852 /// # Permissions853 /// 854 /// * Collection Owner855 /// * Collection Admin856 /// 857 /// # Arguments858 /// 859 /// * collection_id.860 /// 861 /// * address.862 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]863 #[transactional]864 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{865866 let sender = ensure_signed(origin)?;867 let collection = Self::get_collection(collection_id)?;868 Self::check_owner_or_admin_permissions(&collection, sender)?;869870 <WhiteList<T>>::remove(collection_id, address);871872 Ok(())873 }874875 /// Toggle between normal and white list access for the methods with access for `Anyone`.876 /// 877 /// # Permissions878 /// 879 /// * Collection Owner.880 /// 881 /// # Arguments882 /// 883 /// * collection_id.884 /// 885 /// * mode: [AccessMode]886 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]887 #[transactional]888 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult889 {890 let sender = ensure_signed(origin)?;891892 let mut target_collection = Self::get_collection(collection_id)?;893 Self::check_owner_permissions(&target_collection, sender)?;894 target_collection.access = mode;895 Self::save_collection(target_collection);896897 Ok(())898 }899900 /// Allows Anyone to create tokens if:901 /// * White List is enabled, and902 /// * Address is added to white list, and903 /// * This method was called with True parameter904 /// 905 /// # Permissions906 /// * Collection Owner907 ///908 /// # Arguments909 /// 910 /// * collection_id.911 /// 912 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.913 #[weight = <T as Config>::WeightInfo::set_mint_permission()]914 #[transactional]915 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult916 {917 let sender = ensure_signed(origin)?;918919 let mut target_collection = Self::get_collection(collection_id)?;920 Self::check_owner_permissions(&target_collection, sender)?;921 target_collection.mint_mode = mint_permission;922 Self::save_collection(target_collection);923924 Ok(())925 }926927 /// Change the owner of the collection.928 /// 929 /// # Permissions930 /// 931 /// * Collection Owner.932 /// 933 /// # Arguments934 /// 935 /// * collection_id.936 /// 937 /// * new_owner.938 #[weight = <T as Config>::WeightInfo::change_collection_owner()]939 #[transactional]940 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {941942 let sender = ensure_signed(origin)?;943 let mut target_collection = Self::get_collection(collection_id)?;944 Self::check_owner_permissions(&target_collection, sender)?;945 target_collection.owner = new_owner;946 Self::save_collection(target_collection);947948 Ok(())949 }950951 /// Adds an admin of the Collection.952 /// 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. 953 /// 954 /// # Permissions955 /// 956 /// * Collection Owner.957 /// * Collection Admin.958 /// 959 /// # Arguments960 /// 961 /// * collection_id: ID of the Collection to add admin for.962 /// 963 /// * new_admin_id: Address of new admin to add.964 #[weight = <T as Config>::WeightInfo::add_collection_admin()]965 #[transactional]966 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {967968 let sender = ensure_signed(origin)?;969 let collection = Self::get_collection(collection_id)?;970 Self::check_owner_or_admin_permissions(&collection, sender)?;971 let mut admin_arr: Vec<T::AccountId> = Vec::new();972973 if <AdminList<T>>::contains_key(collection_id)974 {975 admin_arr = <AdminList<T>>::get(collection_id);976 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);977 }978979 // Number of collection admins980 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);981982 admin_arr.push(new_admin_id);983 <AdminList<T>>::insert(collection_id, admin_arr);984985 Ok(())986 }987988 /// 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.989 ///990 /// # Permissions991 /// 992 /// * Collection Owner.993 /// * Collection Admin.994 /// 995 /// # Arguments996 /// 997 /// * collection_id: ID of the Collection to remove admin for.998 /// 999 /// * account_id: Address of admin to remove.1000 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1001 #[transactional]1002 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10031004 let sender = ensure_signed(origin)?;1005 let collection = Self::get_collection(collection_id)?;1006 Self::check_owner_or_admin_permissions(&collection, sender)?;1007 ensure!(<AdminList<T>>::contains_key(collection_id), Error::<T>::AdminNotFound);10081009 let mut admin_arr = <AdminList<T>>::get(collection_id);1010 admin_arr.retain(|i| *i != account_id);1011 <AdminList<T>>::insert(collection_id, admin_arr);10121013 Ok(())1014 }10151016 /// # Permissions1017 /// 1018 /// * Collection Owner1019 /// 1020 /// # Arguments1021 /// 1022 /// * collection_id.1023 /// 1024 /// * new_sponsor.1025 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1026 #[transactional]1027 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10281029 let sender = ensure_signed(origin)?;1030 let mut target_collection = Self::get_collection(collection_id)?;1031 Self::check_owner_permissions(&target_collection, sender)?;10321033 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1034 Self::save_collection(target_collection);10351036 Ok(())1037 }10381039 /// # Permissions1040 /// 1041 /// * Sponsor.1042 /// 1043 /// # Arguments1044 /// 1045 /// * collection_id.1046 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1047 #[transactional]1048 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10491050 let sender = ensure_signed(origin)?;10511052 let mut target_collection = Self::get_collection(collection_id)?;1053 ensure!(1054 target_collection.sponsorship.pending_sponsor() == Some(&sender),1055 Error::<T>::ConfirmUnsetSponsorFail1056 );10571058 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1059 Self::save_collection(target_collection);10601061 Ok(())1062 }10631064 /// Switch back to pay-per-own-transaction model.1065 ///1066 /// # Permissions1067 ///1068 /// * Collection owner.1069 /// 1070 /// # Arguments1071 /// 1072 /// * collection_id.1073 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1074 #[transactional]1075 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10761077 let sender = ensure_signed(origin)?;10781079 let mut target_collection = Self::get_collection(collection_id)?;1080 Self::check_owner_permissions(&target_collection, sender)?;10811082 target_collection.sponsorship = SponsorshipState::Disabled;1083 Self::save_collection(target_collection);10841085 Ok(())1086 }10871088 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1089 /// 1090 /// # Permissions1091 /// 1092 /// * Collection Owner.1093 /// * Collection Admin.1094 /// * Anyone if1095 /// * White List is enabled, and1096 /// * Address is added to white list, and1097 /// * MintPermission is enabled (see SetMintPermission method)1098 /// 1099 /// # Arguments1100 /// 1101 /// * collection_id: ID of the collection.1102 /// 1103 /// * owner: Address, initial owner of the NFT.1104 ///1105 /// * data: Token data to store on chain.1106 // #[weight =1107 // (130_000_000 as Weight)1108 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1109 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1110 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11111112 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1113 #[transactional]1114 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11151116 let sender = ensure_signed(origin)?;11171118 let target_collection = Self::get_collection(collection_id)?;11191120 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1121 Self::validate_create_item_args(&target_collection, &data)?;1122 Self::create_item_no_validation(&target_collection, owner, data)?;11231124 Ok(())1125 }11261127 /// This method creates multiple items in a collection created with CreateCollection method.1128 /// 1129 /// # Permissions1130 /// 1131 /// * Collection Owner.1132 /// * Collection Admin.1133 /// * Anyone if1134 /// * White List is enabled, and1135 /// * Address is added to white list, and1136 /// * MintPermission is enabled (see SetMintPermission method)1137 /// 1138 /// # Arguments1139 /// 1140 /// * collection_id: ID of the collection.1141 /// 1142 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1143 /// 1144 /// * owner: Address, initial owner of the NFT.1145 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1146 .map(|data| { data.len() })1147 .sum())]1148 #[transactional]1149 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11501151 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1152 let sender = ensure_signed(origin)?;11531154 let target_collection = Self::get_collection(collection_id)?;11551156 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11571158 for data in &items_data {1159 Self::validate_create_item_args(&target_collection, data)?;1160 }1161 for data in &items_data {1162 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1163 }11641165 Ok(())1166 }11671168 /// Destroys a concrete instance of NFT.1169 /// 1170 /// # Permissions1171 /// 1172 /// * Collection Owner.1173 /// * Collection Admin.1174 /// * Current NFT Owner.1175 /// 1176 /// # Arguments1177 /// 1178 /// * collection_id: ID of the collection.1179 /// 1180 /// * item_id: ID of NFT to burn.1181 #[weight = <T as Config>::WeightInfo::burn_item()]1182 #[transactional]1183 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11841185 let sender = ensure_signed(origin)?;11861187 // Transfer permissions check1188 let target_collection = Self::get_collection(collection_id)?;1189 ensure!(1190 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1191 (1192 target_collection.limits.owner_can_transfer &&1193 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1194 ),1195 Error::<T>::NoPermission1196 );11971198 if target_collection.access == AccessMode::WhiteList {1199 Self::check_white_list(&target_collection, &sender)?;1200 }12011202 match target_collection.mode1203 {1204 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1205 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1206 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1207 _ => ()1208 };12091210 // call event1211 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12121213 Ok(())1214 }12151216 /// Change ownership of the token.1217 /// 1218 /// # Permissions1219 /// 1220 /// * Collection Owner1221 /// * Collection Admin1222 /// * Current NFT owner1223 ///1224 /// # Arguments1225 /// 1226 /// * recipient: Address of token recipient.1227 /// 1228 /// * collection_id.1229 /// 1230 /// * item_id: ID of the item1231 /// * Non-Fungible Mode: Required.1232 /// * Fungible Mode: Ignored.1233 /// * Re-Fungible Mode: Required.1234 /// 1235 /// * value: Amount to transfer.1236 /// * Non-Fungible Mode: Ignored1237 /// * Fungible Mode: Must specify transferred amount1238 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1239 #[weight = <T as Config>::WeightInfo::transfer()]1240 #[transactional]1241 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1242 let sender = ensure_signed(origin)?;1243 let collection = Self::get_collection(collection_id)?;12441245 Self::transfer_internal(sender, recipient, &collection, item_id, value)1246 }12471248 /// Set, change, or remove approved address to transfer the ownership of the NFT.1249 /// 1250 /// # Permissions1251 /// 1252 /// * Collection Owner1253 /// * Collection Admin1254 /// * Current NFT owner1255 /// 1256 /// # Arguments1257 /// 1258 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1259 /// 1260 /// * collection_id.1261 /// 1262 /// * item_id: ID of the item.1263 #[weight = <T as Config>::WeightInfo::approve()]1264 #[transactional]1265 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12661267 let sender = ensure_signed(origin)?;1268 let target_collection = Self::get_collection(collection_id)?;12691270 Self::token_exists(&target_collection, item_id, &sender)?;12711272 // Transfer permissions check1273 let bypasses_limits = target_collection.limits.owner_can_transfer &&1274 Self::is_owner_or_admin_permissions(1275 &target_collection,1276 sender.clone(),1277 );12781279 let allowance_limit = if bypasses_limits {1280 None1281 } else if let Some(amount) = Self::owned_amount(1282 sender.clone(),1283 &target_collection,1284 item_id,1285 ) {1286 Some(amount)1287 } else {1288 fail!(Error::<T>::NoPermission);1289 };12901291 if target_collection.access == AccessMode::WhiteList {1292 Self::check_white_list(&target_collection, &sender)?;1293 Self::check_white_list(&target_collection, &spender)?;1294 }12951296 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1297 let mut allowance: u128 = amount;1298 if allowance_exists {1299 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1300 }1301 if let Some(limit) = allowance_limit {1302 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1303 }1304 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13051306 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1307 Ok(())1308 }1309 1310 /// 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.1311 /// 1312 /// # Permissions1313 /// * Collection Owner1314 /// * Collection Admin1315 /// * Current NFT owner1316 /// * Address approved by current NFT owner1317 /// 1318 /// # Arguments1319 /// 1320 /// * from: Address that owns token.1321 /// 1322 /// * recipient: Address of token recipient.1323 /// 1324 /// * collection_id.1325 /// 1326 /// * item_id: ID of the item.1327 /// 1328 /// * value: Amount to transfer.1329 #[weight = <T as Config>::WeightInfo::transfer_from()]1330 #[transactional]1331 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13321333 let sender = ensure_signed(origin)?;1334 let target_collection = Self::get_collection(collection_id)?;13351336 let mut appoved_transfer = false;13371338 // Check approval1339 let mut approval: u128 = 0;1340 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1341 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1342 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1343 appoved_transfer = true;1344 }13451346 // Limits check1347 Self::is_correct_transfer(&target_collection, &recipient)?;13481349 // Transfer permissions check 1350 ensure!(1351 appoved_transfer || 1352 (1353 target_collection.limits.owner_can_transfer &&1354 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1355 ),1356 Error::<T>::NoPermission1357 );13581359 if target_collection.access == AccessMode::WhiteList {1360 Self::check_white_list(&target_collection, &sender)?;1361 Self::check_white_list(&target_collection, &recipient)?;1362 }13631364 // Reduce approval by transferred amount or remove if remaining approval drops to 01365 if approval.saturating_sub(value) > 0 {1366 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1367 }1368 else {1369 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1370 }13711372 match target_collection.mode1373 {1374 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from, recipient)?,1375 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1376 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient)?,1377 _ => ()1378 };13791380 Ok(())1381 }13821383 // #[weight = 0]1384 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13851386 // // let no_perm_mes = "You do not have permissions to modify this collection";1387 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1388 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1389 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13901391 // // // on_nft_received call13921393 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13941395 // Ok(())1396 // }13971398 /// Set off-chain data schema.1399 /// 1400 /// # Permissions1401 /// 1402 /// * Collection Owner1403 /// * Collection Admin1404 /// 1405 /// # Arguments1406 /// 1407 /// * collection_id.1408 /// 1409 /// * schema: String representing the offchain data schema.1410 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1411 #[transactional]1412 pub fn set_variable_meta_data (1413 origin,1414 collection_id: CollectionId,1415 item_id: TokenId,1416 data: Vec<u8>1417 ) -> DispatchResult {1418 let sender = ensure_signed(origin)?;1419 1420 let target_collection = Self::get_collection(collection_id)?;1421 Self::token_exists(&target_collection, item_id, &sender)?;14221423 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14241425 // Modify permissions check1426 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1427 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1428 Error::<T>::NoPermission);14291430 match target_collection.mode1431 {1432 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1433 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1434 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1435 _ => fail!(Error::<T>::UnexpectedCollectionType)1436 };14371438 Ok(())1439 }1440 1441 /// Set schema standard1442 /// ImageURL1443 /// Unique1444 /// 1445 /// # Permissions1446 /// 1447 /// * Collection Owner1448 /// * Collection Admin1449 /// 1450 /// # Arguments1451 /// 1452 /// * collection_id.1453 /// 1454 /// * schema: SchemaVersion: enum1455 #[weight = <T as Config>::WeightInfo::set_schema_version()]1456 #[transactional]1457 pub fn set_schema_version(1458 origin,1459 collection_id: CollectionId,1460 version: SchemaVersion1461 ) -> DispatchResult {1462 let sender = ensure_signed(origin)?;1463 let mut target_collection = Self::get_collection(collection_id)?;1464 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1465 target_collection.schema_version = version;1466 Self::save_collection(target_collection);14671468 Ok(())1469 }14701471 /// Set off-chain data schema.1472 /// 1473 /// # Permissions1474 /// 1475 /// * Collection Owner1476 /// * Collection Admin1477 /// 1478 /// # Arguments1479 /// 1480 /// * collection_id.1481 /// 1482 /// * schema: String representing the offchain data schema.1483 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1484 #[transactional]1485 pub fn set_offchain_schema(1486 origin,1487 collection_id: CollectionId,1488 schema: Vec<u8>1489 ) -> DispatchResult {1490 let sender = ensure_signed(origin)?;1491 let mut target_collection = Self::get_collection(collection_id)?;1492 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14931494 // check schema limit1495 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14961497 target_collection.offchain_schema = schema;1498 Self::save_collection(target_collection);14991500 Ok(())1501 }15021503 /// Set const on-chain data schema.1504 /// 1505 /// # Permissions1506 /// 1507 /// * Collection Owner1508 /// * Collection Admin1509 /// 1510 /// # Arguments1511 /// 1512 /// * collection_id.1513 /// 1514 /// * schema: String representing the const on-chain data schema.1515 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1516 #[transactional]1517 pub fn set_const_on_chain_schema (1518 origin,1519 collection_id: CollectionId,1520 schema: Vec<u8>1521 ) -> DispatchResult {1522 let sender = ensure_signed(origin)?;1523 let mut target_collection = Self::get_collection(collection_id)?;1524 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15251526 // check schema limit1527 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15281529 target_collection.const_on_chain_schema = schema;1530 Self::save_collection(target_collection);15311532 Ok(())1533 }15341535 /// Set variable on-chain data schema.1536 /// 1537 /// # Permissions1538 /// 1539 /// * Collection Owner1540 /// * Collection Admin1541 /// 1542 /// # Arguments1543 /// 1544 /// * collection_id.1545 /// 1546 /// * schema: String representing the variable on-chain data schema.1547 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1548 #[transactional]1549 pub fn set_variable_on_chain_schema (1550 origin,1551 collection_id: CollectionId,1552 schema: Vec<u8>1553 ) -> DispatchResult {1554 let sender = ensure_signed(origin)?;1555 let mut target_collection = Self::get_collection(collection_id)?;1556 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15571558 // check schema limit1559 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15601561 target_collection.variable_on_chain_schema = schema;1562 Self::save_collection(target_collection);15631564 Ok(())1565 }15661567 // Sudo permissions function1568 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1569 #[transactional]1570 pub fn set_chain_limits(1571 origin,1572 limits: ChainLimits1573 ) -> DispatchResult {15741575 #[cfg(not(feature = "runtime-benchmarks"))]1576 ensure_root(origin)?;15771578 <ChainLimit>::put(limits);1579 Ok(())1580 }15811582 /// Enable smart contract self-sponsoring.1583 /// 1584 /// # Permissions1585 /// 1586 /// * Contract Owner1587 /// 1588 /// # Arguments1589 /// 1590 /// * contract address1591 /// * enable flag1592 /// 1593 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1594 #[transactional]1595 pub fn enable_contract_sponsoring(1596 origin,1597 contract_address: T::AccountId,1598 enable: bool1599 ) -> DispatchResult {16001601 let sender = ensure_signed(origin)?;16021603 #[cfg(feature = "runtime-benchmarks")]1604 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16051606 Self::ensure_contract_owned(sender, &contract_address)?;16071608 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1609 Ok(())1610 }16111612 /// Set the rate limit for contract sponsoring to specified number of blocks.1613 /// 1614 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1615 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1616 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1617 /// from contract endowment if there are at least B blocks between such transactions. 1618 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1619 /// 1620 /// # Permissions1621 /// 1622 /// * Contract Owner1623 /// 1624 /// # Arguments1625 /// 1626 /// -`contract_address`: Address of the contract to sponsor1627 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1628 /// 1629 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1630 #[transactional]1631 pub fn set_contract_sponsoring_rate_limit(1632 origin,1633 contract_address: T::AccountId,1634 rate_limit: T::BlockNumber1635 ) -> DispatchResult {1636 let sender = ensure_signed(origin)?;16371638 #[cfg(feature = "runtime-benchmarks")]1639 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16401641 Self::ensure_contract_owned(sender, &contract_address)?;1642 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1643 Ok(())1644 }16451646 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1647 /// 1648 /// # Permissions1649 /// 1650 /// * Address that deployed smart contract.1651 /// 1652 /// # Arguments1653 /// 1654 /// -`contract_address`: Address of the contract.1655 /// 1656 /// - `enable`: . 1657 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1658 #[transactional]1659 pub fn toggle_contract_white_list(1660 origin,1661 contract_address: T::AccountId,1662 enable: bool1663 ) -> DispatchResult {1664 let sender = ensure_signed(origin)?;16651666 #[cfg(feature = "runtime-benchmarks")]1667 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16681669 Self::ensure_contract_owned(sender, &contract_address)?;1670 <ContractWhiteListEnabled<T>>::insert(contract_address, enable);1671 Ok(())1672 }1673 1674 /// Add an address to smart contract white list.1675 /// 1676 /// # Permissions1677 /// 1678 /// * Address that deployed smart contract.1679 /// 1680 /// # Arguments1681 /// 1682 /// -`contract_address`: Address of the contract.1683 ///1684 /// -`account_address`: Address to add.1685 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1686 #[transactional]1687 pub fn add_to_contract_white_list(1688 origin,1689 contract_address: T::AccountId,1690 account_address: T::AccountId1691 ) -> DispatchResult {1692 let sender = ensure_signed(origin)?;16931694 #[cfg(feature = "runtime-benchmarks")]1695 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1696 1697 Self::ensure_contract_owned(sender, &contract_address)?; 1698 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1699 Ok(())1700 }17011702 /// Remove an address from smart contract white list.1703 /// 1704 /// # Permissions1705 /// 1706 /// * Address that deployed smart contract.1707 /// 1708 /// # Arguments1709 /// 1710 /// -`contract_address`: Address of the contract.1711 ///1712 /// -`account_address`: Address to remove.1713 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1714 #[transactional]1715 pub fn remove_from_contract_white_list(1716 origin,1717 contract_address: T::AccountId,1718 account_address: T::AccountId1719 ) -> DispatchResult {1720 let sender = ensure_signed(origin)?;17211722 #[cfg(feature = "runtime-benchmarks")]1723 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17241725 Self::ensure_contract_owned(sender, &contract_address)?;1726 <ContractWhiteList<T>>::remove(contract_address, account_address);1727 Ok(())1728 }17291730 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1731 #[transactional]1732 pub fn set_collection_limits(1733 origin,1734 collection_id: u32,1735 new_limits: CollectionLimits<T::BlockNumber>,1736 ) -> DispatchResult {1737 let sender = ensure_signed(origin)?;1738 let mut target_collection = Self::get_collection(collection_id)?;1739 Self::check_owner_permissions(&target_collection, sender.clone())?;1740 let old_limits = &target_collection.limits;1741 let chain_limits = ChainLimit::get();17421743 // collection bounds1744 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1745 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1746 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1747 Error::<T>::CollectionLimitBoundsExceeded);17481749 // token_limit check prev1750 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1751 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17521753 ensure!(1754 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1755 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1756 Error::<T>::OwnerPermissionsCantBeReverted,1757 );17581759 target_collection.limits = new_limits;1760 Self::save_collection(target_collection);17611762 Ok(())1763 } 1764 }1765}17661767impl<T: Config> Module<T> {17681769 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1770 // Limits check1771 Self::is_correct_transfer(target_collection, &recipient)?;17721773 // Transfer permissions check1774 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1775 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1776 Error::<T>::NoPermission);17771778 if target_collection.access == AccessMode::WhiteList {1779 Self::check_white_list(target_collection, &sender)?;1780 Self::check_white_list(target_collection, &recipient)?;1781 }17821783 match target_collection.mode1784 {1785 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1786 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1787 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1788 _ => ()1789 };17901791 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17921793 Ok(())1794 }179517961797 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1798 let collection_id = collection.id;17991800 // check token limit and account token limit1801 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1802 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1803 1804 Ok(())1805 }18061807 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1808 let collection_id = collection.id;18091810 // check token limit and account token limit1811 let total_items: u32 = ItemListIndex::get(collection_id)1812 .checked_add(amount)1813 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1814 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1815 .checked_add(amount)1816 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1817 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1818 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18191820 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1821 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1822 Self::check_white_list(collection, owner)?;1823 Self::check_white_list(collection, sender)?;1824 }18251826 Ok(())1827 }18281829 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1830 match target_collection.mode1831 {1832 CollectionMode::NFT => {1833 if let CreateItemData::NFT(data) = data {1834 // check sizes1835 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1836 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1837 } else {1838 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1839 }1840 },1841 CollectionMode::Fungible(_) => {1842 if let CreateItemData::Fungible(_) = data {1843 } else {1844 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1845 }1846 },1847 CollectionMode::ReFungible => {1848 if let CreateItemData::ReFungible(data) = data {18491850 // check sizes1851 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1852 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18531854 // Check refungibility limits1855 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1856 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1857 } else {1858 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1859 }1860 },1861 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1862 };18631864 Ok(())1865 }18661867 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1868 match data1869 {1870 CreateItemData::NFT(data) => {1871 let item = NftItemType {1872 owner: owner.clone(),1873 const_data: data.const_data,1874 variable_data: data.variable_data1875 };18761877 Self::add_nft_item(collection, item)?;1878 },1879 CreateItemData::Fungible(data) => {1880 Self::add_fungible_item(collection, &owner, data.value)?;1881 },1882 CreateItemData::ReFungible(data) => {1883 let mut owner_list = Vec::new();1884 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18851886 let item = ReFungibleItemType {1887 owner: owner_list,1888 const_data: data.const_data,1889 variable_data: data.variable_data1890 };18911892 Self::add_refungible_item(collection, item)?;1893 }1894 };18951896 Ok(())1897 }18981899 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1900 let collection_id = collection.id;19011902 // Does new owner already have an account?1903 let mut balance: u128 = 0;1904 if <FungibleItemList<T>>::contains_key(collection_id, owner) {1905 balance = <FungibleItemList<T>>::get(collection_id, owner).value;1906 } 19071908 // Mint 1909 let item = FungibleItemType {1910 value: balance + value1911 };1912 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19131914 // Update balance1915 let new_balance = <Balance<T>>::get(collection_id, owner)1916 .checked_add(value)1917 .ok_or(Error::<T>::NumOverflow)?;1918 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19191920 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1921 Ok(())1922 }19231924 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1925 let collection_id = collection.id;19261927 let current_index = <ItemListIndex>::get(collection_id)1928 .checked_add(1)1929 .ok_or(Error::<T>::NumOverflow)?;1930 let itemcopy = item.clone();19311932 ensure!(1933 item.owner.len() == 1,1934 Error::<T>::BadCreateRefungibleCall,1935 );1936 let item_owner = item.owner.first().expect("only one owner is defined");19371938 let value = item_owner.fraction;1939 let owner = item_owner.owner.clone();19401941 Self::add_token_index(collection_id, current_index, &owner)?;19421943 <ItemListIndex>::insert(collection_id, current_index);1944 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19451946 // Update balance1947 let new_balance = <Balance<T>>::get(collection_id, &owner)1948 .checked_add(value)1949 .ok_or(Error::<T>::NumOverflow)?;1950 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19511952 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1953 Ok(())1954 }19551956 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1957 let collection_id = collection.id;19581959 let current_index = <ItemListIndex>::get(collection_id)1960 .checked_add(1)1961 .ok_or(Error::<T>::NumOverflow)?;19621963 let item_owner = item.owner.clone();1964 Self::add_token_index(collection_id, current_index, &item.owner)?;19651966 <ItemListIndex>::insert(collection_id, current_index);1967 <NftItemList<T>>::insert(collection_id, current_index, item);19681969 // Update balance1970 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1971 .checked_add(1)1972 .ok_or(Error::<T>::NumOverflow)?;1973 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19741975 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1976 Ok(())1977 }19781979 fn burn_refungible_item(1980 collection: &CollectionHandle<T>,1981 item_id: TokenId,1982 owner: &T::AccountId,1983 ) -> DispatchResult {1984 let collection_id = collection.id;19851986 ensure!(1987 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1988 Error::<T>::TokenNotFound1989 );1990 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id);1991 let rft_balance = token1992 .owner1993 .iter()1994 .find(|&i| i.owner == *owner)1995 .ok_or(Error::<T>::TokenNotFound)?;1996 Self::remove_token_index(collection_id, item_id, owner)?;19971998 // update balance1999 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2000 .checked_sub(rft_balance.fraction)2001 .ok_or(Error::<T>::NumOverflow)?;2002 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20032004 // Re-create owners list with sender removed2005 let index = token2006 .owner2007 .iter()2008 .position(|i| i.owner == *owner)2009 .expect("owned item is exists");2010 token.owner.remove(index);2011 let owner_count = token.owner.len();20122013 // Burn the token completely if this was the last (only) owner2014 if owner_count == 0 {2015 <ReFungibleItemList<T>>::remove(collection_id, item_id);2016 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2017 }2018 else {2019 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2020 }20212022 Ok(())2023 }20242025 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2026 let collection_id = collection.id;20272028 ensure!(2029 <NftItemList<T>>::contains_key(collection_id, item_id),2030 Error::<T>::TokenNotFound2031 );2032 let item = <NftItemList<T>>::get(collection_id, item_id);2033 Self::remove_token_index(collection_id, item_id, &item.owner)?;20342035 // update balance2036 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2037 .checked_sub(1)2038 .ok_or(Error::<T>::NumOverflow)?;2039 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2040 <NftItemList<T>>::remove(collection_id, item_id);2041 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20422043 Ok(())2044 }20452046 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2047 let collection_id = collection.id;20482049 ensure!(2050 <FungibleItemList<T>>::contains_key(collection_id, owner),2051 Error::<T>::TokenNotFound2052 );2053 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2054 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20552056 // update balance2057 let new_balance = <Balance<T>>::get(collection_id, owner)2058 .checked_sub(value)2059 .ok_or(Error::<T>::NumOverflow)?;2060 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20612062 if balance.value - value > 0 {2063 balance.value -= value;2064 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2065 }2066 else {2067 <FungibleItemList<T>>::remove(collection_id, owner);2068 }20692070 Ok(())2071 }20722073 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2074 Ok(<CollectionById<T>>::get(collection_id)2075 .map(|collection| CollectionHandle {2076 id: collection_id,2077 collection2078 })2079 .ok_or(Error::<T>::CollectionNotFound)?)2080 }20812082 fn save_collection(collection: CollectionHandle<T>) {2083 <CollectionById<T>>::insert(collection.id, collection.collection);2084 }20852086 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2087 ensure!(2088 subject == target_collection.owner,2089 Error::<T>::NoPermission2090 );20912092 Ok(())2093 }20942095 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2096 let mut result: bool = subject == collection.owner;2097 let exists = <AdminList<T>>::contains_key(collection.id);20982099 if !result & exists {2100 if <AdminList<T>>::get(collection.id).contains(&subject) {2101 result = true2102 }2103 }21042105 result2106 }21072108 fn check_owner_or_admin_permissions(2109 collection: &CollectionHandle<T>,2110 subject: T::AccountId,2111 ) -> DispatchResult {2112 let result = Self::is_owner_or_admin_permissions(collection, subject.clone());21132114 ensure!(2115 result,2116 Error::<T>::NoPermission2117 );2118 Ok(())2119 }21202121 fn owned_amount(2122 subject: T::AccountId,2123 target_collection: &CollectionHandle<T>,2124 item_id: TokenId,2125 ) -> Option<u128> {2126 let collection_id = target_collection.id;21272128 match target_collection.mode {2129 CollectionMode::NFT => {2130 if <NftItemList<T>>::get(collection_id, item_id).owner == subject {2131 return Some(1)2132 }2133 None2134 },2135 CollectionMode::Fungible(_) => {2136 if <FungibleItemList<T>>::contains_key(collection_id, &subject) {2137 return Some(<FungibleItemList<T>>::get(collection_id, &subject)2138 .value);2139 }2140 None2141 },2142 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)2143 .owner2144 .iter()2145 .find(|i| i.owner == subject)2146 .map(|i| i.fraction),2147 CollectionMode::Invalid => None,2148 }2149 }21502151 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2152 let collection_id = target_collection.id;21532154 match target_collection.mode {2155 CollectionMode::NFT => {2156 <NftItemList<T>>::get(collection_id, item_id).owner == subject2157 }2158 CollectionMode::Fungible(_) => {2159 <FungibleItemList<T>>::contains_key(collection_id, &subject)2160 }2161 CollectionMode::ReFungible => {2162 <ReFungibleItemList<T>>::get(collection_id, item_id)2163 .owner2164 .iter()2165 .any(|i| i.owner == subject)2166 }2167 CollectionMode::Invalid => false,2168 }2169 }21702171 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2172 let collection_id = collection.id;21732174 let mes = Error::<T>::AddresNotInWhiteList;2175 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21762177 Ok(())2178 }21792180 /// Check if token exists. In case of Fungible, check if there is an entry for 2181 /// the owner in fungible balances double map2182 fn token_exists(2183 target_collection: &CollectionHandle<T>,2184 item_id: TokenId,2185 owner: &T::AccountId2186 ) -> DispatchResult {2187 let collection_id = target_collection.id;2188 let exists = match target_collection.mode2189 {2190 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2191 CollectionMode::Fungible(_) => <FungibleItemList<T>>::contains_key(collection_id, owner),2192 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2193 _ => false2194 };21952196 ensure!(exists == true, Error::<T>::TokenNotFound);2197 Ok(())2198 }21992200 fn transfer_fungible(2201 collection: &CollectionHandle<T>,2202 value: u128,2203 owner: &T::AccountId,2204 recipient: &T::AccountId,2205 ) -> DispatchResult {2206 let collection_id = collection.id;2207 Self::token_exists(&collection, 0, owner)?;22082209 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2210 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22112212 // Send balance to recipient (updates balanceOf of recipient)2213 Self::add_fungible_item(collection, recipient, value)?;22142215 // update balanceOf of sender2216 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22172218 // Reduce or remove sender2219 if balance.value == value {2220 <FungibleItemList<T>>::remove(collection_id, owner);2221 }2222 else {2223 balance.value -= value;2224 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2225 }22262227 Ok(())2228 }22292230 fn transfer_refungible(2231 collection: &CollectionHandle<T>,2232 item_id: TokenId,2233 value: u128,2234 owner: T::AccountId,2235 new_owner: T::AccountId,2236 ) -> DispatchResult {2237 let collection_id = collection.id;2238 Self::token_exists(collection, item_id, &owner)?;22392240 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);2241 let item = full_item2242 .owner2243 .iter()2244 .filter(|i| i.owner == owner)2245 .next()2246 .ok_or(Error::<T>::TokenNotFound)?;2247 let amount = item.fraction;22482249 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22502251 // update balance2252 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2253 .checked_sub(value)2254 .ok_or(Error::<T>::NumOverflow)?;2255 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22562257 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2258 .checked_add(value)2259 .ok_or(Error::<T>::NumOverflow)?;2260 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22612262 let old_owner = item.owner.clone();2263 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22642265 // transfer2266 if amount == value && !new_owner_has_account {2267 // change owner2268 // new owner do not have account2269 let mut new_full_item = full_item.clone();2270 new_full_item2271 .owner2272 .iter_mut()2273 .find(|i| i.owner == owner)2274 .expect("old owner does present in refungible")2275 .owner = new_owner.clone();2276 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22772278 // update index collection2279 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2280 } else {2281 let mut new_full_item = full_item.clone();2282 new_full_item2283 .owner2284 .iter_mut()2285 .find(|i| i.owner == owner)2286 .expect("old owner does present in refungible")2287 .fraction -= value;22882289 // separate amount2290 if new_owner_has_account {2291 // new owner has account2292 new_full_item2293 .owner2294 .iter_mut()2295 .find(|i| i.owner == new_owner)2296 .expect("new owner has account")2297 .fraction += value;2298 } else {2299 // new owner do not have account2300 new_full_item.owner.push(Ownership {2301 owner: new_owner.clone(),2302 fraction: value,2303 });2304 Self::add_token_index(collection_id, item_id, &new_owner)?;2305 }23062307 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2308 }23092310 Ok(())2311 }23122313 fn transfer_nft(2314 collection: &CollectionHandle<T>,2315 item_id: TokenId,2316 sender: T::AccountId,2317 new_owner: T::AccountId,2318 ) -> DispatchResult {2319 let collection_id = collection.id;2320 Self::token_exists(&collection, item_id, &sender)?;23212322 let mut item = <NftItemList<T>>::get(collection_id, item_id);23232324 ensure!(2325 sender == item.owner,2326 Error::<T>::MustBeTokenOwner2327 );23282329 // update balance2330 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2331 .checked_sub(1)2332 .ok_or(Error::<T>::NumOverflow)?;2333 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23342335 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2336 .checked_add(1)2337 .ok_or(Error::<T>::NumOverflow)?;2338 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23392340 // change owner2341 let old_owner = item.owner.clone();2342 item.owner = new_owner.clone();2343 <NftItemList<T>>::insert(collection_id, item_id, item);23442345 // update index collection2346 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23472348 Ok(())2349 }2350 2351 fn set_re_fungible_variable_data(2352 collection: &CollectionHandle<T>,2353 item_id: TokenId,2354 data: Vec<u8>2355 ) -> DispatchResult {2356 let collection_id = collection.id;2357 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);23582359 item.variable_data = data;23602361 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23622363 Ok(())2364 }23652366 fn set_nft_variable_data(2367 collection: &CollectionHandle<T>,2368 item_id: TokenId,2369 data: Vec<u8>2370 ) -> DispatchResult {2371 let collection_id = collection.id;2372 let mut item = <NftItemList<T>>::get(collection_id, item_id);2373 2374 item.variable_data = data;23752376 <NftItemList<T>>::insert(collection_id, item_id, item);2377 2378 Ok(())2379 }23802381 fn init_collection(item: &Collection<T>) {2382 // check params2383 assert!(2384 item.decimal_points <= MAX_DECIMAL_POINTS,2385 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2386 );2387 assert!(2388 item.name.len() <= 64,2389 "Collection name can not be longer than 63 char"2390 );2391 assert!(2392 item.name.len() <= 256,2393 "Collection description can not be longer than 255 char"2394 );2395 assert!(2396 item.token_prefix.len() <= 16,2397 "Token prefix can not be longer than 15 char"2398 );23992400 // Generate next collection ID2401 let next_id = CreatedCollectionCount::get()2402 .checked_add(1)2403 .unwrap();24042405 CreatedCollectionCount::put(next_id);2406 }24072408 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2409 let current_index = <ItemListIndex>::get(collection_id)2410 .checked_add(1)2411 .unwrap();24122413 let item_owner = item.owner.clone();2414 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24152416 <ItemListIndex>::insert(collection_id, current_index);24172418 // Update balance2419 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2420 .checked_add(1)2421 .unwrap();2422 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2423 }24242425 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2426 let current_index = <ItemListIndex>::get(collection_id)2427 .checked_add(1)2428 .unwrap();24292430 Self::add_token_index(collection_id, current_index, owner).unwrap();24312432 <ItemListIndex>::insert(collection_id, current_index);24332434 // Update balance2435 let new_balance = <Balance<T>>::get(collection_id, owner)2436 .checked_add(item.value)2437 .unwrap();2438 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2439 }24402441 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2442 let current_index = <ItemListIndex>::get(collection_id)2443 .checked_add(1)2444 .unwrap();24452446 let value = item.owner.first().unwrap().fraction;2447 let owner = item.owner.first().unwrap().owner.clone();24482449 Self::add_token_index(collection_id, current_index, &owner).unwrap();24502451 <ItemListIndex>::insert(collection_id, current_index);24522453 // Update balance2454 let new_balance = <Balance<T>>::get(collection_id, &owner)2455 .checked_add(value)2456 .unwrap();2457 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2458 }24592460 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2461 // add to account limit2462 if <AccountItemCount<T>>::contains_key(owner) {24632464 // bound Owned tokens by a single address2465 let count = <AccountItemCount<T>>::get(owner);2466 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24672468 <AccountItemCount<T>>::insert(owner.clone(), count2469 .checked_add(1)2470 .ok_or(Error::<T>::NumOverflow)?);2471 }2472 else {2473 <AccountItemCount<T>>::insert(owner.clone(), 1);2474 }24752476 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2477 if list_exists {2478 let mut list = <AddressTokens<T>>::get(collection_id, owner);2479 let item_contains = list.contains(&item_index.clone());24802481 if !item_contains {2482 list.push(item_index.clone());2483 }24842485 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2486 } else {2487 let mut itm = Vec::new();2488 itm.push(item_index.clone());2489 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2490 }24912492 Ok(())2493 }24942495 fn remove_token_index(2496 collection_id: CollectionId,2497 item_index: TokenId,2498 owner: &T::AccountId,2499 ) -> DispatchResult {25002501 // update counter2502 <AccountItemCount<T>>::insert(owner.clone(), 2503 <AccountItemCount<T>>::get(owner)2504 .checked_sub(1)2505 .ok_or(Error::<T>::NumOverflow)?);250625072508 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2509 if list_exists {2510 let mut list = <AddressTokens<T>>::get(collection_id, owner);2511 let item_contains = list.contains(&item_index.clone());25122513 if item_contains {2514 list.retain(|&item| item != item_index);2515 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2516 }2517 }25182519 Ok(())2520 }25212522 fn move_token_index(2523 collection_id: CollectionId,2524 item_index: TokenId,2525 old_owner: &T::AccountId,2526 new_owner: &T::AccountId,2527 ) -> DispatchResult {2528 Self::remove_token_index(collection_id, item_index, old_owner)?;2529 Self::add_token_index(collection_id, item_index, new_owner)?;25302531 Ok(())2532 }2533 2534 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2535 if <ContractOwner<T>>::contains_key(contract.clone()) {2536 let owner = <ContractOwner<T>>::get(contract);2537 ensure!(account == owner, Error::<T>::NoPermission);2538 } else {2539 fail!(Error::<T>::NoPermission);2540 }25412542 Ok(())2543 }2544}25452546////////////////////////////////////////////////////////////////////////////////////////////////////2547// Economic models2548// #region25492550/// Fee multiplier.2551pub type Multiplier = FixedU128;25522553type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25542555/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2556/// in the queue.2557#[derive(Encode, Decode, Clone, Eq, PartialEq)]2558pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25592560impl<T: Config + Send + Sync> sp_std::fmt::Debug 2561 for ChargeTransactionPayment<T>2562{2563 #[cfg(feature = "std")]2564 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2565 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2566 }2567 #[cfg(not(feature = "std"))]2568 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2569 Ok(())2570 }2571}25722573impl<T: Config> ChargeTransactionPayment<T>2574where2575 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2576 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2577 T::AccountId: AsRef<[u8]>,2578 T::AccountId: UncheckedFrom<T::Hash>,2579{2580 fn traditional_fee(2581 len: usize,2582 info: &DispatchInfoOf<T::Call>,2583 tip: BalanceOf<T>,2584 ) -> BalanceOf<T>2585 where2586 T::Call: Dispatchable<Info = DispatchInfo>,2587 {2588 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2589 }25902591 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2592 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2593 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2594 let len_saturation = max_block_length as u64 / (len as u64).max(1);2595 let coefficient: BalanceOf<T> = weight_saturation2596 .min(len_saturation)2597 .saturated_into::<BalanceOf<T>>();2598 final_fee2599 .saturating_mul(coefficient)2600 .saturated_into::<TransactionPriority>()2601 }26022603 fn withdraw_fee(2604 &self,2605 who: &T::AccountId,2606 call: &T::Call,2607 info: &DispatchInfoOf<T::Call>,2608 len: usize,2609 ) -> Result<2610 (2611 BalanceOf<T>,2612 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2613 ),2614 TransactionValidityError,2615 > {2616 let tip = self.0;26172618 let fee = Self::traditional_fee(len, info, tip);26192620 // Only mess with balances if fee is not zero.2621 if fee.is_zero() {2622 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2623 .map(|i| (fee, i));2624 }26252626 // Determine who is paying transaction fee based on ecnomic model2627 // Parse call to extract collection ID and access collection sponsor2628 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2629 Some(Call::create_item(collection_id, _owner, _properties)) => {2630 let collection = <CollectionById<T>>::get(collection_id)?;26312632 // sponsor timeout2633 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26342635 let limit = collection.limits.sponsor_transfer_timeout;2636 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2637 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2638 let limit_time = last_tx_block + limit.into();2639 if block_number <= limit_time {2640 return None;2641 }2642 }2643 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26442645 // check free create limit2646 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2647 collection.sponsorship.sponsor()2648 .cloned()2649 } else {2650 None2651 }2652 }2653 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2654 let collection = <CollectionById<T>>::get(collection_id)?;2655 2656 let mut sponsor_transfer = false;2657 if collection.sponsorship.confirmed() {26582659 let collection_limits = collection.limits;2660 let collection_mode = collection.mode;2661 2662 // sponsor timeout2663 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2664 sponsor_transfer = match collection_mode {2665 CollectionMode::NFT => {2666 2667 // get correct limit2668 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2669 collection_limits.sponsor_transfer_timeout2670 } else {2671 ChainLimit::get().nft_sponsor_transfer_timeout2672 };2673 2674 let mut sponsored = true;2675 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2676 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2677 let limit_time = last_tx_block + limit.into();2678 if block_number <= limit_time {2679 sponsored = false;2680 }2681 }2682 if sponsored {2683 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2684 }26852686 sponsored2687 }2688 CollectionMode::Fungible(_) => {2689 2690 // get correct limit2691 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2692 collection_limits.sponsor_transfer_timeout2693 } else {2694 ChainLimit::get().fungible_sponsor_transfer_timeout2695 };2696 2697 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2698 let mut sponsored = true;2699 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2700 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2701 let limit_time = last_tx_block + limit.into();2702 if block_number <= limit_time {2703 sponsored = false;2704 }2705 }2706 if sponsored {2707 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2708 }27092710 sponsored2711 }2712 CollectionMode::ReFungible => {2713 2714 // get correct limit2715 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2716 collection_limits.sponsor_transfer_timeout2717 } else {2718 ChainLimit::get().refungible_sponsor_transfer_timeout2719 };2720 2721 let mut sponsored = true;2722 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2723 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2724 let limit_time = last_tx_block + limit.into();2725 if block_number <= limit_time {2726 sponsored = false;2727 }2728 }2729 if sponsored {2730 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2731 }27322733 sponsored2734 }2735 _ => {2736 false2737 },2738 };2739 }27402741 if !sponsor_transfer {2742 None2743 } else {2744 collection.sponsorship.sponsor()2745 .cloned()2746 }2747 }27482749 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2750 let mut sponsor_metadata_changes = false;27512752 let collection = <CollectionById<T>>::get(collection_id)?;27532754 if2755 collection.sponsorship.confirmed() &&2756 // Can't sponsor fungible collection, this tx will be rejected2757 // as invalid2758 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2759 data.len() <= collection.limits.sponsored_data_size as usize2760 {2761 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2762 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27632764 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2765 .map(|last_block| block_number - last_block > rate_limit)2766 .unwrap_or(true) 2767 {2768 sponsor_metadata_changes = true;2769 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2770 }2771 }2772 }27732774 if !sponsor_metadata_changes {2775 None2776 } else {2777 collection.sponsorship.sponsor().cloned()2778 }2779 }27802781 _ => None,2782 })();27832784 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2785 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27862787 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27882789 let owned_contract = <ContractOwner<T>>::contains_key(called_contract.clone())2790 && <ContractOwner<T>>::get(called_contract.clone()) == *who;2791 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone()) && <ContractWhiteListEnabled<T>>::get(called_contract.clone());2792 2793 if !owned_contract && white_list_enabled {2794 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2795 return Err(InvalidTransaction::Call.into());2796 }2797 }2798 },2799 _ => {},2800 }28012802 // Sponsor smart contracts2803 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28042805 // On instantiation: set the contract owner2806 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28072808 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2809 &who,2810 code_hash,2811 salt,2812 );2813 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28142815 None2816 },28172818 // On instantiation with code: set the contract owner2819 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28202821 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2822 &who,2823 &T::Hashing::hash(&_code),2824 _salt,2825 );28262827 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28282829 None2830 }28312832 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2833 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28342835 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28362837 let mut sponsor_transfer = false;2838 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2839 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2840 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2841 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2842 let limit_time = last_tx_block + rate_limit;28432844 if block_number >= limit_time {2845 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2846 sponsor_transfer = true;2847 }2848 } else {2849 sponsor_transfer = false;2850 }2851 2852 if sponsor_transfer {2853 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2854 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2855 return Some(called_contract);2856 }2857 }2858 }28592860 None2861 },28622863 _ => None,2864 });28652866 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28672868 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2869 .map(|i| (fee, i))2870 }2871}287228732874impl<T: Config + Send + Sync> SignedExtension2875 for ChargeTransactionPayment<T>2876where2877 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2878 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2879 T::AccountId: AsRef<[u8]>,2880 T::AccountId: UncheckedFrom<T::Hash>,2881{2882 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2883 type AccountId = T::AccountId;2884 type Call = T::Call;2885 type AdditionalSigned = ();2886 type Pre = (2887 // tip2888 BalanceOf<T>,2889 // who pays fee2890 Self::AccountId,2891 // imbalance resulting from withdrawing the fee2892 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2893 );2894 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2895 Ok(())2896 }28972898 fn validate(2899 &self,2900 who: &Self::AccountId,2901 call: &Self::Call,2902 info: &DispatchInfoOf<Self::Call>,2903 len: usize,2904 ) -> TransactionValidity {2905 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2906 Ok(ValidTransaction {2907 priority: Self::get_priority(len, info, fee),2908 ..Default::default()2909 })2910 }29112912 fn pre_dispatch(2913 self,2914 who: &Self::AccountId,2915 call: &Self::Call,2916 info: &DispatchInfoOf<Self::Call>,2917 len: usize,2918 ) -> Result<Self::Pre, TransactionValidityError> {2919 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2920 Ok((self.0, who.clone(), imbalance))2921 }29222923 fn post_dispatch(2924 pre: Self::Pre,2925 info: &DispatchInfoOf<Self::Call>,2926 post_info: &PostDispatchInfoOf<Self::Call>,2927 len: usize,2928 _result: &DispatchResult,2929 ) -> Result<(), TransactionValidityError> {2930 let (tip, who, imbalance) = pre;2931 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2932 len as u32,2933 info,2934 post_info,2935 tip,2936 );2937 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2938 Ok(())2939 }2940}29412942// #endregion