difftreelog
Rename Created event to CollectionCreated
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, 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, 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 /// TODO: Off chain worker should remove from this map when token gets removed541 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543 //#region Item collections544 /// Collection id (controlled?2), token id (controlled?1)545 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546 /// Collection id (controlled?2), owner (controlled?2)547 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548 /// Collection id (controlled?2), token id (controlled?1)549 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550 //#endregion551552 //#region Index list553 /// Collection id (controlled?2), tokens owner (controlled?2)554 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555 //#endregion556557 //#region Tokens transfer rate limit baskets558 /// (Collection id (controlled?2), who created (real))559 /// TODO: Off chain worker should remove from this map when collection gets removed560 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561 /// Collection id (controlled?2), token id (controlled?2)562 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563 /// Collection id (controlled?2), owning user (real)564 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565 /// Collection id (controlled?2), token id (controlled?2)566 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567 //#endregion568569 /// Variable metadata sponsoring570 /// Collection id (controlled?2), token id (controlled?2)571 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572 573 //#region Contract Sponsorship and Ownership574 /// Contract address (real)575 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576 /// Contract address (real)577 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578 /// (Contract address(real), caller (real))579 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580 /// Contract address (real)581 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582 /// Contract address (real)583 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584 /// Contract address (real) => Whitelisted user (controlled?3)585 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586 //#endregion587 }588 add_extra_genesis {589 build(|config: &GenesisConfig<T>| {590 // Modification of storage591 for (_num, _c) in &config.collection_id {592 <Module<T>>::init_collection(_c);593 }594595 for (_num, _c, _i) in &config.nft_item_id {596 <Module<T>>::init_nft_token(*_c, _i);597 }598599 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601 }602603 for (_num, _c, _i) in &config.refungible_item_id {604 <Module<T>>::init_refungible_token(*_c, _i);605 }606 })607 }608}609610decl_event!(611 pub enum Event<T>612 where613 AccountId = <T as system::Config>::AccountId,614 {615 /// New collection was created616 /// 617 /// # Arguments618 /// 619 /// * collection_id: Globally unique identifier of newly created collection.620 /// 621 /// * mode: [CollectionMode] converted into u8.622 /// 623 /// * account_id: Collection owner.624 Created(CollectionId, u8, AccountId),625626 /// New item was created.627 /// 628 /// # Arguments629 /// 630 /// * collection_id: Id of the collection where item was created.631 /// 632 /// * item_id: Id of an item. Unique within the collection.633 ///634 /// * recipient: Owner of newly created item 635 ItemCreated(CollectionId, TokenId, AccountId),636637 /// Collection item was burned.638 /// 639 /// # Arguments640 /// 641 /// collection_id.642 /// 643 /// item_id: Identifier of burned NFT.644 ItemDestroyed(CollectionId, TokenId),645646 /// Item was transferred647 ///648 /// * collection_id: Id of collection to which item is belong649 ///650 /// * item_id: Id of an item651 ///652 /// * sender: Original owner of item653 ///654 /// * recipient: New owner of item655 ///656 /// * amount: Always 1 for NFT657 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659 /// * collection_id660 ///661 /// * item_id662 ///663 /// * sender664 ///665 /// * spender666 ///667 /// * amount668 Approved(CollectionId, TokenId, AccountId, AccountId, u128),669 }670);671672decl_module! {673 pub struct Module<T: Config> for enum Call 674 where 675 origin: T::Origin676 {677 fn deposit_event() = default;678 type Error = Error<T>;679680 fn on_initialize(now: T::BlockNumber) -> Weight {681 0682 }683684 /// 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.685 /// 686 /// # Permissions687 /// 688 /// * Anyone.689 /// 690 /// # Arguments691 /// 692 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.693 /// 694 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.695 /// 696 /// * token_prefix: UTF-8 string with token prefix.697 /// 698 /// * mode: [CollectionMode] collection type and type dependent data.699 // returns collection ID700 #[weight = <T as Config>::WeightInfo::create_collection()]701 #[transactional]702 pub fn create_collection(origin,703 collection_name: Vec<u16>,704 collection_description: Vec<u16>,705 token_prefix: Vec<u8>,706 mode: CollectionMode) -> DispatchResult {707708 // Anyone can create a collection709 let who = ensure_signed(origin)?;710711 // Take a (non-refundable) deposit of collection creation712 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714 &T::TreasuryAccountId::get(),715 T::CollectionCreationPrice::get(),716 ));717 <T as Config>::Currency::settle(718 &who,719 imbalance,720 WithdrawReasons::TRANSFER,721 ExistenceRequirement::KeepAlive,722 ).map_err(|_| Error::<T>::NoPermission)?;723724 let decimal_points = match mode {725 CollectionMode::Fungible(points) => points,726 _ => 0727 };728729 let chain_limit = ChainLimit::get();730731 let created_count = CreatedCollectionCount::get();732 let destroyed_count = DestroyedCollectionCount::get();733734 // bound Total number of collections735 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737 // check params738 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743 // Generate next collection ID744 let next_id = created_count745 .checked_add(1)746 .ok_or(Error::<T>::NumOverflow)?;747748 CreatedCollectionCount::put(next_id);749750 let limits = CollectionLimits {751 sponsored_data_size: chain_limit.custom_data_limit,752 ..Default::default()753 };754755 // Create new collection756 let new_collection = Collection {757 owner: who.clone(),758 name: collection_name,759 mode: mode.clone(),760 mint_mode: false,761 access: AccessMode::Normal,762 description: collection_description,763 decimal_points: decimal_points,764 token_prefix: token_prefix,765 offchain_schema: Vec::new(),766 schema_version: SchemaVersion::ImageURL,767 sponsorship: SponsorshipState::Disabled,768 variable_on_chain_schema: Vec::new(),769 const_on_chain_schema: Vec::new(),770 limits,771 };772773 // Add new collection to map774 <CollectionById<T>>::insert(next_id, new_collection);775776 // call event777 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));778779 Ok(())780 }781782 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.783 /// 784 /// # Permissions785 /// 786 /// * Collection Owner.787 /// 788 /// # Arguments789 /// 790 /// * collection_id: collection to destroy.791 #[weight = <T as Config>::WeightInfo::destroy_collection()]792 #[transactional]793 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795 let sender = ensure_signed(origin)?;796 let collection = Self::get_collection(collection_id)?;797 Self::check_owner_permissions(&collection, sender)?;798 if !collection.limits.owner_can_destroy {799 fail!(Error::<T>::NoPermission);800 }801802 <AddressTokens<T>>::remove_prefix(collection_id);803 <Allowances<T>>::remove_prefix(collection_id);804 <Balance<T>>::remove_prefix(collection_id);805 <ItemListIndex>::remove(collection_id);806 <AdminList<T>>::remove(collection_id);807 <CollectionById<T>>::remove(collection_id);808 <WhiteList<T>>::remove_prefix(collection_id);809810 <NftItemList<T>>::remove_prefix(collection_id);811 <FungibleItemList<T>>::remove_prefix(collection_id);812 <ReFungibleItemList<T>>::remove_prefix(collection_id);813814 <NftTransferBasket<T>>::remove_prefix(collection_id);815 <FungibleTransferBasket<T>>::remove_prefix(collection_id);816 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820 DestroyedCollectionCount::put(DestroyedCollectionCount::get()821 .checked_add(1)822 .ok_or(Error::<T>::NumOverflow)?);823824 Ok(())825 }826827 /// Add an address to white list.828 /// 829 /// # Permissions830 /// 831 /// * Collection Owner832 /// * Collection Admin833 /// 834 /// # Arguments835 /// 836 /// * collection_id.837 /// 838 /// * address.839 #[weight = <T as Config>::WeightInfo::add_to_white_list()]840 #[transactional]841 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843 let sender = ensure_signed(origin)?;844 let collection = Self::get_collection(collection_id)?;845 Self::check_owner_or_admin_permissions(&collection, sender)?;846847 <WhiteList<T>>::insert(collection_id, address, true);848 849 Ok(())850 }851852 /// Remove an address from white list.853 /// 854 /// # Permissions855 /// 856 /// * Collection Owner857 /// * Collection Admin858 /// 859 /// # Arguments860 /// 861 /// * collection_id.862 /// 863 /// * address.864 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]865 #[transactional]866 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{867868 let sender = ensure_signed(origin)?;869 let collection = Self::get_collection(collection_id)?;870 Self::check_owner_or_admin_permissions(&collection, sender)?;871872 <WhiteList<T>>::remove(collection_id, address);873874 Ok(())875 }876877 /// Toggle between normal and white list access for the methods with access for `Anyone`.878 /// 879 /// # Permissions880 /// 881 /// * Collection Owner.882 /// 883 /// # Arguments884 /// 885 /// * collection_id.886 /// 887 /// * mode: [AccessMode]888 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]889 #[transactional]890 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult891 {892 let sender = ensure_signed(origin)?;893894 let mut target_collection = Self::get_collection(collection_id)?;895 Self::check_owner_permissions(&target_collection, sender)?;896 target_collection.access = mode;897 Self::save_collection(target_collection);898899 Ok(())900 }901902 /// Allows Anyone to create tokens if:903 /// * White List is enabled, and904 /// * Address is added to white list, and905 /// * This method was called with True parameter906 /// 907 /// # Permissions908 /// * Collection Owner909 ///910 /// # Arguments911 /// 912 /// * collection_id.913 /// 914 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.915 #[weight = <T as Config>::WeightInfo::set_mint_permission()]916 #[transactional]917 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult918 {919 let sender = ensure_signed(origin)?;920921 let mut target_collection = Self::get_collection(collection_id)?;922 Self::check_owner_permissions(&target_collection, sender)?;923 target_collection.mint_mode = mint_permission;924 Self::save_collection(target_collection);925926 Ok(())927 }928929 /// Change the owner of the collection.930 /// 931 /// # Permissions932 /// 933 /// * Collection Owner.934 /// 935 /// # Arguments936 /// 937 /// * collection_id.938 /// 939 /// * new_owner.940 #[weight = <T as Config>::WeightInfo::change_collection_owner()]941 #[transactional]942 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {943944 let sender = ensure_signed(origin)?;945 let mut target_collection = Self::get_collection(collection_id)?;946 Self::check_owner_permissions(&target_collection, sender)?;947 target_collection.owner = new_owner;948 Self::save_collection(target_collection);949950 Ok(())951 }952953 /// Adds an admin of the Collection.954 /// 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. 955 /// 956 /// # Permissions957 /// 958 /// * Collection Owner.959 /// * Collection Admin.960 /// 961 /// # Arguments962 /// 963 /// * collection_id: ID of the Collection to add admin for.964 /// 965 /// * new_admin_id: Address of new admin to add.966 #[weight = <T as Config>::WeightInfo::add_collection_admin()]967 #[transactional]968 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {969970 let sender = ensure_signed(origin)?;971 let collection = Self::get_collection(collection_id)?;972 Self::check_owner_or_admin_permissions(&collection, sender)?;973 let mut admin_arr = <AdminList<T>>::get(collection_id);974975 match admin_arr.binary_search(&new_admin_id) {976 Ok(_) => {},977 Err(idx) => {978 let limits = ChainLimit::get();979 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);980 admin_arr.insert(idx, new_admin_id);981 <AdminList<T>>::insert(collection_id, admin_arr);982 }983 }984 Ok(())985 }986987 /// 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.988 ///989 /// # Permissions990 /// 991 /// * Collection Owner.992 /// * Collection Admin.993 /// 994 /// # Arguments995 /// 996 /// * collection_id: ID of the Collection to remove admin for.997 /// 998 /// * account_id: Address of admin to remove.999 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1000 #[transactional]1001 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10021003 let sender = ensure_signed(origin)?;1004 let collection = Self::get_collection(collection_id)?;1005 Self::check_owner_or_admin_permissions(&collection, sender)?;1006 let mut admin_arr = <AdminList<T>>::get(collection_id);10071008 match admin_arr.binary_search(&account_id) {1009 Ok(idx) => {1010 admin_arr.remove(idx);1011 <AdminList<T>>::insert(collection_id, admin_arr);1012 },1013 Err(_) => {}1014 }1015 Ok(())1016 }10171018 /// # Permissions1019 /// 1020 /// * Collection Owner1021 /// 1022 /// # Arguments1023 /// 1024 /// * collection_id.1025 /// 1026 /// * new_sponsor.1027 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1028 #[transactional]1029 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10301031 let sender = ensure_signed(origin)?;1032 let mut target_collection = Self::get_collection(collection_id)?;1033 Self::check_owner_permissions(&target_collection, sender)?;10341035 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1036 Self::save_collection(target_collection);10371038 Ok(())1039 }10401041 /// # Permissions1042 /// 1043 /// * Sponsor.1044 /// 1045 /// # Arguments1046 /// 1047 /// * collection_id.1048 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1049 #[transactional]1050 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10511052 let sender = ensure_signed(origin)?;10531054 let mut target_collection = Self::get_collection(collection_id)?;1055 ensure!(1056 target_collection.sponsorship.pending_sponsor() == Some(&sender),1057 Error::<T>::ConfirmUnsetSponsorFail1058 );10591060 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1061 Self::save_collection(target_collection);10621063 Ok(())1064 }10651066 /// Switch back to pay-per-own-transaction model.1067 ///1068 /// # Permissions1069 ///1070 /// * Collection owner.1071 /// 1072 /// # Arguments1073 /// 1074 /// * collection_id.1075 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1076 #[transactional]1077 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10781079 let sender = ensure_signed(origin)?;10801081 let mut target_collection = Self::get_collection(collection_id)?;1082 Self::check_owner_permissions(&target_collection, sender)?;10831084 target_collection.sponsorship = SponsorshipState::Disabled;1085 Self::save_collection(target_collection);10861087 Ok(())1088 }10891090 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1091 /// 1092 /// # Permissions1093 /// 1094 /// * Collection Owner.1095 /// * Collection Admin.1096 /// * Anyone if1097 /// * White List is enabled, and1098 /// * Address is added to white list, and1099 /// * MintPermission is enabled (see SetMintPermission method)1100 /// 1101 /// # Arguments1102 /// 1103 /// * collection_id: ID of the collection.1104 /// 1105 /// * owner: Address, initial owner of the NFT.1106 ///1107 /// * data: Token data to store on chain.1108 // #[weight =1109 // (130_000_000 as Weight)1110 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1111 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1112 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11131114 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1115 #[transactional]1116 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11171118 let sender = ensure_signed(origin)?;11191120 let target_collection = Self::get_collection(collection_id)?;11211122 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1123 Self::validate_create_item_args(&target_collection, &data)?;1124 Self::create_item_no_validation(&target_collection, owner, data)?;11251126 Ok(())1127 }11281129 /// This method creates multiple items in a collection created with CreateCollection method.1130 /// 1131 /// # Permissions1132 /// 1133 /// * Collection Owner.1134 /// * Collection Admin.1135 /// * Anyone if1136 /// * White List is enabled, and1137 /// * Address is added to white list, and1138 /// * MintPermission is enabled (see SetMintPermission method)1139 /// 1140 /// # Arguments1141 /// 1142 /// * collection_id: ID of the collection.1143 /// 1144 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1145 /// 1146 /// * owner: Address, initial owner of the NFT.1147 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148 .map(|data| { data.len() })1149 .sum())]1150 #[transactional]1151 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154 let sender = ensure_signed(origin)?;11551156 let target_collection = Self::get_collection(collection_id)?;11571158 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160 for data in &items_data {1161 Self::validate_create_item_args(&target_collection, data)?;1162 }1163 for data in &items_data {1164 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165 }11661167 Ok(())1168 }11691170 /// Destroys a concrete instance of NFT.1171 /// 1172 /// # Permissions1173 /// 1174 /// * Collection Owner.1175 /// * Collection Admin.1176 /// * Current NFT Owner.1177 /// 1178 /// # Arguments1179 /// 1180 /// * collection_id: ID of the collection.1181 /// 1182 /// * item_id: ID of NFT to burn.1183 #[weight = <T as Config>::WeightInfo::burn_item()]1184 #[transactional]1185 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187 let sender = ensure_signed(origin)?;11881189 // Transfer permissions check1190 let target_collection = Self::get_collection(collection_id)?;1191 ensure!(1192 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193 (1194 target_collection.limits.owner_can_transfer &&1195 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196 ),1197 Error::<T>::NoPermission1198 );11991200 if target_collection.access == AccessMode::WhiteList {1201 Self::check_white_list(&target_collection, &sender)?;1202 }12031204 match target_collection.mode1205 {1206 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1208 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209 _ => ()1210 };12111212 // call event1213 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215 Ok(())1216 }12171218 /// Change ownership of the token.1219 /// 1220 /// # Permissions1221 /// 1222 /// * Collection Owner1223 /// * Collection Admin1224 /// * Current NFT owner1225 ///1226 /// # Arguments1227 /// 1228 /// * recipient: Address of token recipient.1229 /// 1230 /// * collection_id.1231 /// 1232 /// * item_id: ID of the item1233 /// * Non-Fungible Mode: Required.1234 /// * Fungible Mode: Ignored.1235 /// * Re-Fungible Mode: Required.1236 /// 1237 /// * value: Amount to transfer.1238 /// * Non-Fungible Mode: Ignored1239 /// * Fungible Mode: Must specify transferred amount1240 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1241 #[weight = <T as Config>::WeightInfo::transfer()]1242 #[transactional]1243 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244 let sender = ensure_signed(origin)?;1245 let collection = Self::get_collection(collection_id)?;12461247 Self::transfer_internal(sender, recipient, &collection, item_id, value)1248 }12491250 /// Set, change, or remove approved address to transfer the ownership of the NFT.1251 /// 1252 /// # Permissions1253 /// 1254 /// * Collection Owner1255 /// * Collection Admin1256 /// * Current NFT owner1257 /// 1258 /// # Arguments1259 /// 1260 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1261 /// 1262 /// * collection_id.1263 /// 1264 /// * item_id: ID of the item.1265 #[weight = <T as Config>::WeightInfo::approve()]1266 #[transactional]1267 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269 let sender = ensure_signed(origin)?;1270 let target_collection = Self::get_collection(collection_id)?;12711272 Self::token_exists(&target_collection, item_id)?;12731274 // Transfer permissions check1275 let bypasses_limits = target_collection.limits.owner_can_transfer &&1276 Self::is_owner_or_admin_permissions(1277 &target_collection,1278 sender.clone(),1279 );12801281 let allowance_limit = if bypasses_limits {1282 None1283 } else if let Some(amount) = Self::owned_amount(1284 sender.clone(),1285 &target_collection,1286 item_id,1287 ) {1288 Some(amount)1289 } else {1290 fail!(Error::<T>::NoPermission);1291 };12921293 if target_collection.access == AccessMode::WhiteList {1294 Self::check_white_list(&target_collection, &sender)?;1295 Self::check_white_list(&target_collection, &spender)?;1296 }12971298 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1299 let mut allowance: u128 = amount;1300 if allowance_exists {1301 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1302 }1303 if let Some(limit) = allowance_limit {1304 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1305 }1306 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13071308 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1309 Ok(())1310 }1311 1312 /// 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.1313 /// 1314 /// # Permissions1315 /// * Collection Owner1316 /// * Collection Admin1317 /// * Current NFT owner1318 /// * Address approved by current NFT owner1319 /// 1320 /// # Arguments1321 /// 1322 /// * from: Address that owns token.1323 /// 1324 /// * recipient: Address of token recipient.1325 /// 1326 /// * collection_id.1327 /// 1328 /// * item_id: ID of the item.1329 /// 1330 /// * value: Amount to transfer.1331 #[weight = <T as Config>::WeightInfo::transfer_from()]1332 #[transactional]1333 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13341335 let sender = ensure_signed(origin)?;1336 let target_collection = Self::get_collection(collection_id)?;13371338 let mut appoved_transfer = false;13391340 // Check approval1341 let mut approval: u128 = 0;1342 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1343 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1344 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1345 appoved_transfer = true;1346 }13471348 // Limits check1349 Self::is_correct_transfer(&target_collection, &recipient)?;13501351 // Transfer permissions check 1352 ensure!(1353 appoved_transfer || 1354 (1355 target_collection.limits.owner_can_transfer &&1356 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1357 ),1358 Error::<T>::NoPermission1359 );13601361 if target_collection.access == AccessMode::WhiteList {1362 Self::check_white_list(&target_collection, &sender)?;1363 Self::check_white_list(&target_collection, &recipient)?;1364 }13651366 // Reduce approval by transferred amount or remove if remaining approval drops to 01367 if approval.saturating_sub(value) > 0 {1368 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1369 }1370 else {1371 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1372 }13731374 match target_collection.mode1375 {1376 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1377 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1378 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1379 _ => ()1380 };13811382 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1383 Ok(())1384 }13851386 // #[weight = 0]1387 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13881389 // // let no_perm_mes = "You do not have permissions to modify this collection";1390 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1391 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1392 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13931394 // // // on_nft_received call13951396 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13971398 // Ok(())1399 // }14001401 /// Set off-chain data schema.1402 /// 1403 /// # Permissions1404 /// 1405 /// * Collection Owner1406 /// * Collection Admin1407 /// 1408 /// # Arguments1409 /// 1410 /// * collection_id.1411 /// 1412 /// * schema: String representing the offchain data schema.1413 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1414 #[transactional]1415 pub fn set_variable_meta_data (1416 origin,1417 collection_id: CollectionId,1418 item_id: TokenId,1419 data: Vec<u8>1420 ) -> DispatchResult {1421 let sender = ensure_signed(origin)?;1422 1423 let target_collection = Self::get_collection(collection_id)?;1424 Self::token_exists(&target_collection, item_id)?;14251426 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14271428 // Modify permissions check1429 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1430 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1431 Error::<T>::NoPermission);14321433 match target_collection.mode1434 {1435 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1436 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1437 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1438 _ => fail!(Error::<T>::UnexpectedCollectionType)1439 };14401441 Ok(())1442 }1443 1444 /// Set schema standard1445 /// ImageURL1446 /// Unique1447 /// 1448 /// # Permissions1449 /// 1450 /// * Collection Owner1451 /// * Collection Admin1452 /// 1453 /// # Arguments1454 /// 1455 /// * collection_id.1456 /// 1457 /// * schema: SchemaVersion: enum1458 #[weight = <T as Config>::WeightInfo::set_schema_version()]1459 #[transactional]1460 pub fn set_schema_version(1461 origin,1462 collection_id: CollectionId,1463 version: SchemaVersion1464 ) -> DispatchResult {1465 let sender = ensure_signed(origin)?;1466 let mut target_collection = Self::get_collection(collection_id)?;1467 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1468 target_collection.schema_version = version;1469 Self::save_collection(target_collection);14701471 Ok(())1472 }14731474 /// Set off-chain data schema.1475 /// 1476 /// # Permissions1477 /// 1478 /// * Collection Owner1479 /// * Collection Admin1480 /// 1481 /// # Arguments1482 /// 1483 /// * collection_id.1484 /// 1485 /// * schema: String representing the offchain data schema.1486 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1487 #[transactional]1488 pub fn set_offchain_schema(1489 origin,1490 collection_id: CollectionId,1491 schema: Vec<u8>1492 ) -> DispatchResult {1493 let sender = ensure_signed(origin)?;1494 let mut target_collection = Self::get_collection(collection_id)?;1495 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14961497 // check schema limit1498 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14991500 target_collection.offchain_schema = schema;1501 Self::save_collection(target_collection);15021503 Ok(())1504 }15051506 /// Set const on-chain data schema.1507 /// 1508 /// # Permissions1509 /// 1510 /// * Collection Owner1511 /// * Collection Admin1512 /// 1513 /// # Arguments1514 /// 1515 /// * collection_id.1516 /// 1517 /// * schema: String representing the const on-chain data schema.1518 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1519 #[transactional]1520 pub fn set_const_on_chain_schema (1521 origin,1522 collection_id: CollectionId,1523 schema: Vec<u8>1524 ) -> DispatchResult {1525 let sender = ensure_signed(origin)?;1526 let mut target_collection = Self::get_collection(collection_id)?;1527 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15281529 // check schema limit1530 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15311532 target_collection.const_on_chain_schema = schema;1533 Self::save_collection(target_collection);15341535 Ok(())1536 }15371538 /// Set variable on-chain data schema.1539 /// 1540 /// # Permissions1541 /// 1542 /// * Collection Owner1543 /// * Collection Admin1544 /// 1545 /// # Arguments1546 /// 1547 /// * collection_id.1548 /// 1549 /// * schema: String representing the variable on-chain data schema.1550 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1551 #[transactional]1552 pub fn set_variable_on_chain_schema (1553 origin,1554 collection_id: CollectionId,1555 schema: Vec<u8>1556 ) -> DispatchResult {1557 let sender = ensure_signed(origin)?;1558 let mut target_collection = Self::get_collection(collection_id)?;1559 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15601561 // check schema limit1562 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15631564 target_collection.variable_on_chain_schema = schema;1565 Self::save_collection(target_collection);15661567 Ok(())1568 }15691570 // Sudo permissions function1571 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1572 #[transactional]1573 pub fn set_chain_limits(1574 origin,1575 limits: ChainLimits1576 ) -> DispatchResult {15771578 #[cfg(not(feature = "runtime-benchmarks"))]1579 ensure_root(origin)?;15801581 <ChainLimit>::put(limits);1582 Ok(())1583 }15841585 /// Enable smart contract self-sponsoring.1586 /// 1587 /// # Permissions1588 /// 1589 /// * Contract Owner1590 /// 1591 /// # Arguments1592 /// 1593 /// * contract address1594 /// * enable flag1595 /// 1596 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1597 #[transactional]1598 pub fn enable_contract_sponsoring(1599 origin,1600 contract_address: T::AccountId,1601 enable: bool1602 ) -> DispatchResult {16031604 let sender = ensure_signed(origin)?;16051606 #[cfg(feature = "runtime-benchmarks")]1607 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16081609 Self::ensure_contract_owned(sender, &contract_address)?;16101611 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1612 Ok(())1613 }16141615 /// Set the rate limit for contract sponsoring to specified number of blocks.1616 /// 1617 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1618 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1619 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1620 /// from contract endowment if there are at least B blocks between such transactions. 1621 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1622 /// 1623 /// # Permissions1624 /// 1625 /// * Contract Owner1626 /// 1627 /// # Arguments1628 /// 1629 /// -`contract_address`: Address of the contract to sponsor1630 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1631 /// 1632 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1633 #[transactional]1634 pub fn set_contract_sponsoring_rate_limit(1635 origin,1636 contract_address: T::AccountId,1637 rate_limit: T::BlockNumber1638 ) -> DispatchResult {1639 let sender = ensure_signed(origin)?;16401641 #[cfg(feature = "runtime-benchmarks")]1642 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16431644 Self::ensure_contract_owned(sender, &contract_address)?;1645 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1646 Ok(())1647 }16481649 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1650 /// 1651 /// # Permissions1652 /// 1653 /// * Address that deployed smart contract.1654 /// 1655 /// # Arguments1656 /// 1657 /// -`contract_address`: Address of the contract.1658 /// 1659 /// - `enable`: . 1660 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1661 #[transactional]1662 pub fn toggle_contract_white_list(1663 origin,1664 contract_address: T::AccountId,1665 enable: bool1666 ) -> DispatchResult {1667 let sender = ensure_signed(origin)?;16681669 #[cfg(feature = "runtime-benchmarks")]1670 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16711672 Self::ensure_contract_owned(sender, &contract_address)?;1673 if enable {1674 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1675 } else {1676 <ContractWhiteListEnabled<T>>::remove(contract_address);1677 }1678 Ok(())1679 }1680 1681 /// Add an address to smart contract white list.1682 /// 1683 /// # Permissions1684 /// 1685 /// * Address that deployed smart contract.1686 /// 1687 /// # Arguments1688 /// 1689 /// -`contract_address`: Address of the contract.1690 ///1691 /// -`account_address`: Address to add.1692 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1693 #[transactional]1694 pub fn add_to_contract_white_list(1695 origin,1696 contract_address: T::AccountId,1697 account_address: T::AccountId1698 ) -> DispatchResult {1699 let sender = ensure_signed(origin)?;17001701 #[cfg(feature = "runtime-benchmarks")]1702 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1703 1704 Self::ensure_contract_owned(sender, &contract_address)?; 1705 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1706 Ok(())1707 }17081709 /// Remove an address from smart contract white list.1710 /// 1711 /// # Permissions1712 /// 1713 /// * Address that deployed smart contract.1714 /// 1715 /// # Arguments1716 /// 1717 /// -`contract_address`: Address of the contract.1718 ///1719 /// -`account_address`: Address to remove.1720 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1721 #[transactional]1722 pub fn remove_from_contract_white_list(1723 origin,1724 contract_address: T::AccountId,1725 account_address: T::AccountId1726 ) -> DispatchResult {1727 let sender = ensure_signed(origin)?;17281729 #[cfg(feature = "runtime-benchmarks")]1730 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17311732 Self::ensure_contract_owned(sender, &contract_address)?;1733 <ContractWhiteList<T>>::remove(contract_address, account_address);1734 Ok(())1735 }17361737 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1738 #[transactional]1739 pub fn set_collection_limits(1740 origin,1741 collection_id: u32,1742 new_limits: CollectionLimits<T::BlockNumber>,1743 ) -> DispatchResult {1744 let sender = ensure_signed(origin)?;1745 let mut target_collection = Self::get_collection(collection_id)?;1746 Self::check_owner_permissions(&target_collection, sender.clone())?;1747 let old_limits = &target_collection.limits;1748 let chain_limits = ChainLimit::get();17491750 // collection bounds1751 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1752 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1753 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1754 Error::<T>::CollectionLimitBoundsExceeded);17551756 // token_limit check prev1757 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1758 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17591760 ensure!(1761 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1762 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1763 Error::<T>::OwnerPermissionsCantBeReverted,1764 );17651766 target_collection.limits = new_limits;1767 Self::save_collection(target_collection);17681769 Ok(())1770 } 1771 }1772}17731774impl<T: Config> Module<T> {17751776 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1777 // Limits check1778 Self::is_correct_transfer(target_collection, &recipient)?;17791780 // Transfer permissions check1781 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1782 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1783 Error::<T>::NoPermission);17841785 if target_collection.access == AccessMode::WhiteList {1786 Self::check_white_list(target_collection, &sender)?;1787 Self::check_white_list(target_collection, &recipient)?;1788 }17891790 match target_collection.mode1791 {1792 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1793 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1794 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1795 _ => ()1796 };17971798 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17991800 Ok(())1801 }180218031804 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1805 let collection_id = collection.id;18061807 // check token limit and account token limit1808 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1809 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1810 1811 Ok(())1812 }18131814 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1815 let collection_id = collection.id;18161817 // check token limit and account token limit1818 let total_items: u32 = ItemListIndex::get(collection_id)1819 .checked_add(amount)1820 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1821 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1822 .checked_add(amount)1823 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1824 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1825 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18261827 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1828 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1829 Self::check_white_list(collection, owner)?;1830 Self::check_white_list(collection, sender)?;1831 }18321833 Ok(())1834 }18351836 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1837 match target_collection.mode1838 {1839 CollectionMode::NFT => {1840 if let CreateItemData::NFT(data) = data {1841 // check sizes1842 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1843 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1844 } else {1845 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1846 }1847 },1848 CollectionMode::Fungible(_) => {1849 if let CreateItemData::Fungible(_) = data {1850 } else {1851 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1852 }1853 },1854 CollectionMode::ReFungible => {1855 if let CreateItemData::ReFungible(data) = data {18561857 // check sizes1858 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1859 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18601861 // Check refungibility limits1862 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1863 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1864 } else {1865 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1866 }1867 },1868 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1869 };18701871 Ok(())1872 }18731874 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1875 match data1876 {1877 CreateItemData::NFT(data) => {1878 let item = NftItemType {1879 owner: owner.clone(),1880 const_data: data.const_data,1881 variable_data: data.variable_data1882 };18831884 Self::add_nft_item(collection, item)?;1885 },1886 CreateItemData::Fungible(data) => {1887 Self::add_fungible_item(collection, &owner, data.value)?;1888 },1889 CreateItemData::ReFungible(data) => {1890 let mut owner_list = Vec::new();1891 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18921893 let item = ReFungibleItemType {1894 owner: owner_list,1895 const_data: data.const_data,1896 variable_data: data.variable_data1897 };18981899 Self::add_refungible_item(collection, item)?;1900 }1901 };19021903 Ok(())1904 }19051906 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1907 let collection_id = collection.id;19081909 // Does new owner already have an account?1910 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19111912 // Mint 1913 let item = FungibleItemType {1914 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1915 };1916 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19171918 // Update balance1919 let new_balance = <Balance<T>>::get(collection_id, owner)1920 .checked_add(value)1921 .ok_or(Error::<T>::NumOverflow)?;1922 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19231924 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1925 Ok(())1926 }19271928 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1929 let collection_id = collection.id;19301931 let current_index = <ItemListIndex>::get(collection_id)1932 .checked_add(1)1933 .ok_or(Error::<T>::NumOverflow)?;1934 let itemcopy = item.clone();19351936 ensure!(1937 item.owner.len() == 1,1938 Error::<T>::BadCreateRefungibleCall,1939 );1940 let item_owner = item.owner.first().expect("only one owner is defined");19411942 let value = item_owner.fraction;1943 let owner = item_owner.owner.clone();19441945 Self::add_token_index(collection_id, current_index, &owner)?;19461947 <ItemListIndex>::insert(collection_id, current_index);1948 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19491950 // Update balance1951 let new_balance = <Balance<T>>::get(collection_id, &owner)1952 .checked_add(value)1953 .ok_or(Error::<T>::NumOverflow)?;1954 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19551956 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1957 Ok(())1958 }19591960 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1961 let collection_id = collection.id;19621963 let current_index = <ItemListIndex>::get(collection_id)1964 .checked_add(1)1965 .ok_or(Error::<T>::NumOverflow)?;19661967 let item_owner = item.owner.clone();1968 Self::add_token_index(collection_id, current_index, &item.owner)?;19691970 <ItemListIndex>::insert(collection_id, current_index);1971 <NftItemList<T>>::insert(collection_id, current_index, item);19721973 // Update balance1974 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1975 .checked_add(1)1976 .ok_or(Error::<T>::NumOverflow)?;1977 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19781979 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1980 Ok(())1981 }19821983 fn burn_refungible_item(1984 collection: &CollectionHandle<T>,1985 item_id: TokenId,1986 owner: &T::AccountId,1987 ) -> DispatchResult {1988 let collection_id = collection.id;19891990 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1991 .ok_or(Error::<T>::TokenNotFound)?;1992 let rft_balance = token1993 .owner1994 .iter()1995 .find(|&i| i.owner == *owner)1996 .ok_or(Error::<T>::TokenNotFound)?;1997 Self::remove_token_index(collection_id, item_id, owner)?;19981999 // update balance2000 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2001 .checked_sub(rft_balance.fraction)2002 .ok_or(Error::<T>::NumOverflow)?;2003 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20042005 // Re-create owners list with sender removed2006 let index = token2007 .owner2008 .iter()2009 .position(|i| i.owner == *owner)2010 .expect("owned item is exists");2011 token.owner.remove(index);2012 let owner_count = token.owner.len();20132014 // Burn the token completely if this was the last (only) owner2015 if owner_count == 0 {2016 <ReFungibleItemList<T>>::remove(collection_id, item_id);2017 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2018 }2019 else {2020 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2021 }20222023 Ok(())2024 }20252026 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2027 let collection_id = collection.id;20282029 let item = <NftItemList<T>>::get(collection_id, item_id)2030 .ok_or(Error::<T>::TokenNotFound)?;2031 Self::remove_token_index(collection_id, item_id, &item.owner)?;20322033 // update balance2034 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2035 .checked_sub(1)2036 .ok_or(Error::<T>::NumOverflow)?;2037 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2038 <NftItemList<T>>::remove(collection_id, item_id);2039 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20402041 Ok(())2042 }20432044 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2045 let collection_id = collection.id;20462047 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2048 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20492050 // update balance2051 let new_balance = <Balance<T>>::get(collection_id, owner)2052 .checked_sub(value)2053 .ok_or(Error::<T>::NumOverflow)?;2054 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20552056 if balance.value - value > 0 {2057 balance.value -= value;2058 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2059 }2060 else {2061 <FungibleItemList<T>>::remove(collection_id, owner);2062 }20632064 Ok(())2065 }20662067 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2068 Ok(<CollectionById<T>>::get(collection_id)2069 .map(|collection| CollectionHandle {2070 id: collection_id,2071 collection2072 })2073 .ok_or(Error::<T>::CollectionNotFound)?)2074 }20752076 fn save_collection(collection: CollectionHandle<T>) {2077 <CollectionById<T>>::insert(collection.id, collection.collection);2078 }20792080 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2081 ensure!(2082 subject == target_collection.owner,2083 Error::<T>::NoPermission2084 );20852086 Ok(())2087 }20882089 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2090 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2091 }20922093 fn check_owner_or_admin_permissions(2094 collection: &CollectionHandle<T>,2095 subject: T::AccountId,2096 ) -> DispatchResult {2097 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20982099 Ok(())2100 }21012102 fn owned_amount(2103 subject: T::AccountId,2104 target_collection: &CollectionHandle<T>,2105 item_id: TokenId,2106 ) -> Option<u128> {2107 let collection_id = target_collection.id;21082109 match target_collection.mode {2110 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2111 .then(|| 1),2112 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2113 .value),2114 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2115 .owner2116 .iter()2117 .find(|i| i.owner == subject)2118 .map(|i| i.fraction),2119 CollectionMode::Invalid => None,2120 }2121 }21222123 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2124 match target_collection.mode {2125 CollectionMode::Fungible(_) => true,2126 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2127 }2128 }21292130 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2131 let collection_id = collection.id;21322133 let mes = Error::<T>::AddresNotInWhiteList;2134 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21352136 Ok(())2137 }21382139 /// Check if token exists. In case of Fungible, check if there is an entry for 2140 /// the owner in fungible balances double map2141 fn token_exists(2142 target_collection: &CollectionHandle<T>,2143 item_id: TokenId,2144 ) -> DispatchResult {2145 let collection_id = target_collection.id;2146 let exists = match target_collection.mode2147 {2148 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2149 CollectionMode::Fungible(_) => true,2150 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2151 _ => false2152 };21532154 ensure!(exists == true, Error::<T>::TokenNotFound);2155 Ok(())2156 }21572158 fn transfer_fungible(2159 collection: &CollectionHandle<T>,2160 value: u128,2161 owner: &T::AccountId,2162 recipient: &T::AccountId,2163 ) -> DispatchResult {2164 let collection_id = collection.id;21652166 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2167 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21682169 // Send balance to recipient (updates balanceOf of recipient)2170 Self::add_fungible_item(collection, recipient, value)?;21712172 // update balanceOf of sender2173 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21742175 // Reduce or remove sender2176 if balance.value == value {2177 <FungibleItemList<T>>::remove(collection_id, owner);2178 }2179 else {2180 balance.value -= value;2181 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2182 }21832184 Ok(())2185 }21862187 fn transfer_refungible(2188 collection: &CollectionHandle<T>,2189 item_id: TokenId,2190 value: u128,2191 owner: T::AccountId,2192 new_owner: T::AccountId,2193 ) -> DispatchResult {2194 let collection_id = collection.id;2195 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2196 .ok_or(Error::<T>::TokenNotFound)?;21972198 let item = full_item2199 .owner2200 .iter()2201 .filter(|i| i.owner == owner)2202 .next()2203 .ok_or(Error::<T>::TokenNotFound)?;2204 let amount = item.fraction;22052206 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22072208 // update balance2209 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2210 .checked_sub(value)2211 .ok_or(Error::<T>::NumOverflow)?;2212 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22132214 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2215 .checked_add(value)2216 .ok_or(Error::<T>::NumOverflow)?;2217 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22182219 let old_owner = item.owner.clone();2220 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22212222 // transfer2223 if amount == value && !new_owner_has_account {2224 // change owner2225 // new owner do not have account2226 let mut new_full_item = full_item.clone();2227 new_full_item2228 .owner2229 .iter_mut()2230 .find(|i| i.owner == owner)2231 .expect("old owner does present in refungible")2232 .owner = new_owner.clone();2233 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22342235 // update index collection2236 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2237 } else {2238 let mut new_full_item = full_item.clone();2239 new_full_item2240 .owner2241 .iter_mut()2242 .find(|i| i.owner == owner)2243 .expect("old owner does present in refungible")2244 .fraction -= value;22452246 // separate amount2247 if new_owner_has_account {2248 // new owner has account2249 new_full_item2250 .owner2251 .iter_mut()2252 .find(|i| i.owner == new_owner)2253 .expect("new owner has account")2254 .fraction += value;2255 } else {2256 // new owner do not have account2257 new_full_item.owner.push(Ownership {2258 owner: new_owner.clone(),2259 fraction: value,2260 });2261 Self::add_token_index(collection_id, item_id, &new_owner)?;2262 }22632264 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2265 }22662267 Ok(())2268 }22692270 fn transfer_nft(2271 collection: &CollectionHandle<T>,2272 item_id: TokenId,2273 sender: T::AccountId,2274 new_owner: T::AccountId,2275 ) -> DispatchResult {2276 let collection_id = collection.id;2277 let mut item = <NftItemList<T>>::get(collection_id, item_id)2278 .ok_or(Error::<T>::TokenNotFound)?;22792280 ensure!(2281 sender == item.owner,2282 Error::<T>::MustBeTokenOwner2283 );22842285 // update balance2286 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2287 .checked_sub(1)2288 .ok_or(Error::<T>::NumOverflow)?;2289 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22902291 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2292 .checked_add(1)2293 .ok_or(Error::<T>::NumOverflow)?;2294 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22952296 // change owner2297 let old_owner = item.owner.clone();2298 item.owner = new_owner.clone();2299 <NftItemList<T>>::insert(collection_id, item_id, item);23002301 // update index collection2302 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23032304 Ok(())2305 }2306 2307 fn set_re_fungible_variable_data(2308 collection: &CollectionHandle<T>,2309 item_id: TokenId,2310 data: Vec<u8>2311 ) -> DispatchResult {2312 let collection_id = collection.id;2313 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2314 .ok_or(Error::<T>::TokenNotFound)?;23152316 item.variable_data = data;23172318 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23192320 Ok(())2321 }23222323 fn set_nft_variable_data(2324 collection: &CollectionHandle<T>,2325 item_id: TokenId,2326 data: Vec<u8>2327 ) -> DispatchResult {2328 let collection_id = collection.id;2329 let mut item = <NftItemList<T>>::get(collection_id, item_id)2330 .ok_or(Error::<T>::TokenNotFound)?;2331 2332 item.variable_data = data;23332334 <NftItemList<T>>::insert(collection_id, item_id, item);2335 2336 Ok(())2337 }23382339 fn init_collection(item: &Collection<T>) {2340 // check params2341 assert!(2342 item.decimal_points <= MAX_DECIMAL_POINTS,2343 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2344 );2345 assert!(2346 item.name.len() <= 64,2347 "Collection name can not be longer than 63 char"2348 );2349 assert!(2350 item.name.len() <= 256,2351 "Collection description can not be longer than 255 char"2352 );2353 assert!(2354 item.token_prefix.len() <= 16,2355 "Token prefix can not be longer than 15 char"2356 );23572358 // Generate next collection ID2359 let next_id = CreatedCollectionCount::get()2360 .checked_add(1)2361 .unwrap();23622363 CreatedCollectionCount::put(next_id);2364 }23652366 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2367 let current_index = <ItemListIndex>::get(collection_id)2368 .checked_add(1)2369 .unwrap();23702371 let item_owner = item.owner.clone();2372 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23732374 <ItemListIndex>::insert(collection_id, current_index);23752376 // Update balance2377 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2378 .checked_add(1)2379 .unwrap();2380 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2381 }23822383 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2384 let current_index = <ItemListIndex>::get(collection_id)2385 .checked_add(1)2386 .unwrap();23872388 Self::add_token_index(collection_id, current_index, owner).unwrap();23892390 <ItemListIndex>::insert(collection_id, current_index);23912392 // Update balance2393 let new_balance = <Balance<T>>::get(collection_id, owner)2394 .checked_add(item.value)2395 .unwrap();2396 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2397 }23982399 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2400 let current_index = <ItemListIndex>::get(collection_id)2401 .checked_add(1)2402 .unwrap();24032404 let value = item.owner.first().unwrap().fraction;2405 let owner = item.owner.first().unwrap().owner.clone();24062407 Self::add_token_index(collection_id, current_index, &owner).unwrap();24082409 <ItemListIndex>::insert(collection_id, current_index);24102411 // Update balance2412 let new_balance = <Balance<T>>::get(collection_id, &owner)2413 .checked_add(value)2414 .unwrap();2415 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2416 }24172418 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2419 // add to account limit2420 if <AccountItemCount<T>>::contains_key(owner) {24212422 // bound Owned tokens by a single address2423 let count = <AccountItemCount<T>>::get(owner);2424 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24252426 <AccountItemCount<T>>::insert(owner.clone(), count2427 .checked_add(1)2428 .ok_or(Error::<T>::NumOverflow)?);2429 }2430 else {2431 <AccountItemCount<T>>::insert(owner.clone(), 1);2432 }24332434 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2435 if list_exists {2436 let mut list = <AddressTokens<T>>::get(collection_id, owner);2437 let item_contains = list.contains(&item_index.clone());24382439 if !item_contains {2440 list.push(item_index.clone());2441 }24422443 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2444 } else {2445 let mut itm = Vec::new();2446 itm.push(item_index.clone());2447 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2448 }24492450 Ok(())2451 }24522453 fn remove_token_index(2454 collection_id: CollectionId,2455 item_index: TokenId,2456 owner: &T::AccountId,2457 ) -> DispatchResult {24582459 // update counter2460 <AccountItemCount<T>>::insert(owner.clone(), 2461 <AccountItemCount<T>>::get(owner)2462 .checked_sub(1)2463 .ok_or(Error::<T>::NumOverflow)?);246424652466 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2467 if list_exists {2468 let mut list = <AddressTokens<T>>::get(collection_id, owner);2469 let item_contains = list.contains(&item_index.clone());24702471 if item_contains {2472 list.retain(|&item| item != item_index);2473 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2474 }2475 }24762477 Ok(())2478 }24792480 fn move_token_index(2481 collection_id: CollectionId,2482 item_index: TokenId,2483 old_owner: &T::AccountId,2484 new_owner: &T::AccountId,2485 ) -> DispatchResult {2486 Self::remove_token_index(collection_id, item_index, old_owner)?;2487 Self::add_token_index(collection_id, item_index, new_owner)?;24882489 Ok(())2490 }2491 2492 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2493 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24942495 Ok(())2496 }2497}24982499////////////////////////////////////////////////////////////////////////////////////////////////////2500// Economic models2501// #region25022503/// Fee multiplier.2504pub type Multiplier = FixedU128;25052506type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25072508/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2509/// in the queue.2510#[derive(Encode, Decode, Clone, Eq, PartialEq)]2511pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25122513impl<T: Config + Send + Sync> sp_std::fmt::Debug 2514 for ChargeTransactionPayment<T>2515{2516 #[cfg(feature = "std")]2517 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2518 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2519 }2520 #[cfg(not(feature = "std"))]2521 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2522 Ok(())2523 }2524}25252526impl<T: Config> ChargeTransactionPayment<T>2527where2528 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2529 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2530 T::AccountId: AsRef<[u8]>,2531 T::AccountId: UncheckedFrom<T::Hash>,2532{2533 fn traditional_fee(2534 len: usize,2535 info: &DispatchInfoOf<T::Call>,2536 tip: BalanceOf<T>,2537 ) -> BalanceOf<T>2538 where2539 T::Call: Dispatchable<Info = DispatchInfo>,2540 {2541 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2542 }25432544 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2545 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2546 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2547 let len_saturation = max_block_length as u64 / (len as u64).max(1);2548 let coefficient: BalanceOf<T> = weight_saturation2549 .min(len_saturation)2550 .saturated_into::<BalanceOf<T>>();2551 final_fee2552 .saturating_mul(coefficient)2553 .saturated_into::<TransactionPriority>()2554 }25552556 fn withdraw_fee(2557 &self,2558 who: &T::AccountId,2559 call: &T::Call,2560 info: &DispatchInfoOf<T::Call>,2561 len: usize,2562 ) -> Result<2563 (2564 BalanceOf<T>,2565 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2566 ),2567 TransactionValidityError,2568 > {2569 let tip = self.0;25702571 let fee = Self::traditional_fee(len, info, tip);25722573 // Only mess with balances if fee is not zero.2574 if fee.is_zero() {2575 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2576 .map(|i| (fee, i));2577 }25782579 // Determine who is paying transaction fee based on ecnomic model2580 // Parse call to extract collection ID and access collection sponsor2581 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2582 Some(Call::create_item(collection_id, _owner, _properties)) => {2583 let collection = <CollectionById<T>>::get(collection_id)?;25842585 // sponsor timeout2586 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25872588 let limit = collection.limits.sponsor_transfer_timeout;2589 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2590 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2591 let limit_time = last_tx_block + limit.into();2592 if block_number <= limit_time {2593 return None;2594 }2595 }2596 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25972598 // check free create limit2599 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2600 collection.sponsorship.sponsor()2601 .cloned()2602 } else {2603 None2604 }2605 }2606 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2607 let collection = <CollectionById<T>>::get(collection_id)?;2608 2609 let mut sponsor_transfer = false;2610 if collection.sponsorship.confirmed() {26112612 let collection_limits = collection.limits;2613 let collection_mode = collection.mode;2614 2615 // sponsor timeout2616 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2617 sponsor_transfer = match collection_mode {2618 CollectionMode::NFT => {2619 2620 // get correct limit2621 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2622 collection_limits.sponsor_transfer_timeout2623 } else {2624 ChainLimit::get().nft_sponsor_transfer_timeout2625 };2626 2627 let mut sponsored = true;2628 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2629 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2630 let limit_time = last_tx_block + limit.into();2631 if block_number <= limit_time {2632 sponsored = false;2633 }2634 }2635 if sponsored {2636 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2637 }26382639 sponsored2640 }2641 CollectionMode::Fungible(_) => {2642 2643 // get correct limit2644 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2645 collection_limits.sponsor_transfer_timeout2646 } else {2647 ChainLimit::get().fungible_sponsor_transfer_timeout2648 };2649 2650 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2651 let mut sponsored = true;2652 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2653 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2654 let limit_time = last_tx_block + limit.into();2655 if block_number <= limit_time {2656 sponsored = false;2657 }2658 }2659 if sponsored {2660 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2661 }26622663 sponsored2664 }2665 CollectionMode::ReFungible => {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().refungible_sponsor_transfer_timeout2672 };2673 2674 let mut sponsored = true;2675 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2676 let last_tx_block = <ReFungibleTransferBasket<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 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2684 }26852686 sponsored2687 }2688 _ => {2689 false2690 },2691 };2692 }26932694 if !sponsor_transfer {2695 None2696 } else {2697 collection.sponsorship.sponsor()2698 .cloned()2699 }2700 }27012702 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2703 let mut sponsor_metadata_changes = false;27042705 let collection = <CollectionById<T>>::get(collection_id)?;27062707 if2708 collection.sponsorship.confirmed() &&2709 // Can't sponsor fungible collection, this tx will be rejected2710 // as invalid2711 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2712 data.len() <= collection.limits.sponsored_data_size as usize2713 {2714 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2715 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27162717 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2718 .map(|last_block| block_number - last_block > rate_limit)2719 .unwrap_or(true) 2720 {2721 sponsor_metadata_changes = true;2722 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2723 }2724 }2725 }27262727 if !sponsor_metadata_changes {2728 None2729 } else {2730 collection.sponsorship.sponsor().cloned()2731 }2732 }27332734 _ => None,2735 })();27362737 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2738 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27392740 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27412742 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2743 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2744 2745 if !owned_contract && white_list_enabled {2746 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2747 return Err(InvalidTransaction::Call.into());2748 }2749 }2750 },2751 _ => {},2752 }27532754 // Sponsor smart contracts2755 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27562757 // On instantiation: set the contract owner2758 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27592760 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2761 &who,2762 code_hash,2763 salt,2764 );2765 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27662767 None2768 },27692770 // On instantiation with code: set the contract owner2771 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27722773 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2774 &who,2775 &T::Hashing::hash(&_code),2776 _salt,2777 );27782779 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27802781 None2782 }27832784 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2785 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 mut sponsor_transfer = false;2790 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2791 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2792 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2793 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2794 let limit_time = last_tx_block + rate_limit;27952796 if block_number >= limit_time {2797 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2798 sponsor_transfer = true;2799 }2800 } else {2801 sponsor_transfer = false;2802 }2803 2804 if sponsor_transfer {2805 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2806 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2807 return Some(called_contract);2808 }2809 }2810 }28112812 None2813 },28142815 _ => None,2816 });28172818 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28192820 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2821 .map(|i| (fee, i))2822 }2823}282428252826impl<T: Config + Send + Sync> SignedExtension2827 for ChargeTransactionPayment<T>2828where2829 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2830 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2831 T::AccountId: AsRef<[u8]>,2832 T::AccountId: UncheckedFrom<T::Hash>,2833{2834 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2835 type AccountId = T::AccountId;2836 type Call = T::Call;2837 type AdditionalSigned = ();2838 type Pre = (2839 // tip2840 BalanceOf<T>,2841 // who pays fee2842 Self::AccountId,2843 // imbalance resulting from withdrawing the fee2844 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2845 );2846 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2847 Ok(())2848 }28492850 fn validate(2851 &self,2852 who: &Self::AccountId,2853 call: &Self::Call,2854 info: &DispatchInfoOf<Self::Call>,2855 len: usize,2856 ) -> TransactionValidity {2857 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2858 Ok(ValidTransaction {2859 priority: Self::get_priority(len, info, fee),2860 ..Default::default()2861 })2862 }28632864 fn pre_dispatch(2865 self,2866 who: &Self::AccountId,2867 call: &Self::Call,2868 info: &DispatchInfoOf<Self::Call>,2869 len: usize,2870 ) -> Result<Self::Pre, TransactionValidityError> {2871 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2872 Ok((self.0, who.clone(), imbalance))2873 }28742875 fn post_dispatch(2876 pre: Self::Pre,2877 info: &DispatchInfoOf<Self::Call>,2878 post_info: &PostDispatchInfoOf<Self::Call>,2879 len: usize,2880 _result: &DispatchResult,2881 ) -> Result<(), TransactionValidityError> {2882 let (tip, who, imbalance) = pre;2883 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2884 len as u32,2885 info,2886 post_info,2887 tip,2888 );2889 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2890 Ok(())2891 }2892}28932894// #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, 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, 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 /// TODO: Off chain worker should remove from this map when token gets removed541 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543 //#region Item collections544 /// Collection id (controlled?2), token id (controlled?1)545 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546 /// Collection id (controlled?2), owner (controlled?2)547 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548 /// Collection id (controlled?2), token id (controlled?1)549 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550 //#endregion551552 //#region Index list553 /// Collection id (controlled?2), tokens owner (controlled?2)554 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555 //#endregion556557 //#region Tokens transfer rate limit baskets558 /// (Collection id (controlled?2), who created (real))559 /// TODO: Off chain worker should remove from this map when collection gets removed560 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561 /// Collection id (controlled?2), token id (controlled?2)562 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563 /// Collection id (controlled?2), owning user (real)564 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565 /// Collection id (controlled?2), token id (controlled?2)566 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567 //#endregion568569 /// Variable metadata sponsoring570 /// Collection id (controlled?2), token id (controlled?2)571 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572 573 //#region Contract Sponsorship and Ownership574 /// Contract address (real)575 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576 /// Contract address (real)577 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578 /// (Contract address(real), caller (real))579 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580 /// Contract address (real)581 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582 /// Contract address (real)583 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584 /// Contract address (real) => Whitelisted user (controlled?3)585 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586 //#endregion587 }588 add_extra_genesis {589 build(|config: &GenesisConfig<T>| {590 // Modification of storage591 for (_num, _c) in &config.collection_id {592 <Module<T>>::init_collection(_c);593 }594595 for (_num, _c, _i) in &config.nft_item_id {596 <Module<T>>::init_nft_token(*_c, _i);597 }598599 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601 }602603 for (_num, _c, _i) in &config.refungible_item_id {604 <Module<T>>::init_refungible_token(*_c, _i);605 }606 })607 }608}609610decl_event!(611 pub enum Event<T>612 where613 AccountId = <T as system::Config>::AccountId,614 {615 /// New collection was created616 /// 617 /// # Arguments618 /// 619 /// * collection_id: Globally unique identifier of newly created collection.620 /// 621 /// * mode: [CollectionMode] converted into u8.622 /// 623 /// * account_id: Collection owner.624 CollectionCreated(CollectionId, u8, AccountId),625626 /// New item was created.627 /// 628 /// # Arguments629 /// 630 /// * collection_id: Id of the collection where item was created.631 /// 632 /// * item_id: Id of an item. Unique within the collection.633 ///634 /// * recipient: Owner of newly created item 635 ItemCreated(CollectionId, TokenId, AccountId),636637 /// Collection item was burned.638 /// 639 /// # Arguments640 /// 641 /// collection_id.642 /// 643 /// item_id: Identifier of burned NFT.644 ItemDestroyed(CollectionId, TokenId),645646 /// Item was transferred647 ///648 /// * collection_id: Id of collection to which item is belong649 ///650 /// * item_id: Id of an item651 ///652 /// * sender: Original owner of item653 ///654 /// * recipient: New owner of item655 ///656 /// * amount: Always 1 for NFT657 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659 /// * collection_id660 ///661 /// * item_id662 ///663 /// * sender664 ///665 /// * spender666 ///667 /// * amount668 Approved(CollectionId, TokenId, AccountId, AccountId, u128),669 }670);671672decl_module! {673 pub struct Module<T: Config> for enum Call 674 where 675 origin: T::Origin676 {677 fn deposit_event() = default;678 type Error = Error<T>;679680 fn on_initialize(now: T::BlockNumber) -> Weight {681 0682 }683684 /// 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.685 /// 686 /// # Permissions687 /// 688 /// * Anyone.689 /// 690 /// # Arguments691 /// 692 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.693 /// 694 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.695 /// 696 /// * token_prefix: UTF-8 string with token prefix.697 /// 698 /// * mode: [CollectionMode] collection type and type dependent data.699 // returns collection ID700 #[weight = <T as Config>::WeightInfo::create_collection()]701 #[transactional]702 pub fn create_collection(origin,703 collection_name: Vec<u16>,704 collection_description: Vec<u16>,705 token_prefix: Vec<u8>,706 mode: CollectionMode) -> DispatchResult {707708 // Anyone can create a collection709 let who = ensure_signed(origin)?;710711 // Take a (non-refundable) deposit of collection creation712 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714 &T::TreasuryAccountId::get(),715 T::CollectionCreationPrice::get(),716 ));717 <T as Config>::Currency::settle(718 &who,719 imbalance,720 WithdrawReasons::TRANSFER,721 ExistenceRequirement::KeepAlive,722 ).map_err(|_| Error::<T>::NoPermission)?;723724 let decimal_points = match mode {725 CollectionMode::Fungible(points) => points,726 _ => 0727 };728729 let chain_limit = ChainLimit::get();730731 let created_count = CreatedCollectionCount::get();732 let destroyed_count = DestroyedCollectionCount::get();733734 // bound Total number of collections735 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737 // check params738 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743 // Generate next collection ID744 let next_id = created_count745 .checked_add(1)746 .ok_or(Error::<T>::NumOverflow)?;747748 CreatedCollectionCount::put(next_id);749750 let limits = CollectionLimits {751 sponsored_data_size: chain_limit.custom_data_limit,752 ..Default::default()753 };754755 // Create new collection756 let new_collection = Collection {757 owner: who.clone(),758 name: collection_name,759 mode: mode.clone(),760 mint_mode: false,761 access: AccessMode::Normal,762 description: collection_description,763 decimal_points: decimal_points,764 token_prefix: token_prefix,765 offchain_schema: Vec::new(),766 schema_version: SchemaVersion::ImageURL,767 sponsorship: SponsorshipState::Disabled,768 variable_on_chain_schema: Vec::new(),769 const_on_chain_schema: Vec::new(),770 limits,771 };772773 // Add new collection to map774 <CollectionById<T>>::insert(next_id, new_collection);775776 // call event777 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));778779 Ok(())780 }781782 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.783 /// 784 /// # Permissions785 /// 786 /// * Collection Owner.787 /// 788 /// # Arguments789 /// 790 /// * collection_id: collection to destroy.791 #[weight = <T as Config>::WeightInfo::destroy_collection()]792 #[transactional]793 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795 let sender = ensure_signed(origin)?;796 let collection = Self::get_collection(collection_id)?;797 Self::check_owner_permissions(&collection, sender)?;798 if !collection.limits.owner_can_destroy {799 fail!(Error::<T>::NoPermission);800 }801802 <AddressTokens<T>>::remove_prefix(collection_id);803 <Allowances<T>>::remove_prefix(collection_id);804 <Balance<T>>::remove_prefix(collection_id);805 <ItemListIndex>::remove(collection_id);806 <AdminList<T>>::remove(collection_id);807 <CollectionById<T>>::remove(collection_id);808 <WhiteList<T>>::remove_prefix(collection_id);809810 <NftItemList<T>>::remove_prefix(collection_id);811 <FungibleItemList<T>>::remove_prefix(collection_id);812 <ReFungibleItemList<T>>::remove_prefix(collection_id);813814 <NftTransferBasket<T>>::remove_prefix(collection_id);815 <FungibleTransferBasket<T>>::remove_prefix(collection_id);816 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820 DestroyedCollectionCount::put(DestroyedCollectionCount::get()821 .checked_add(1)822 .ok_or(Error::<T>::NumOverflow)?);823824 Ok(())825 }826827 /// Add an address to white list.828 /// 829 /// # Permissions830 /// 831 /// * Collection Owner832 /// * Collection Admin833 /// 834 /// # Arguments835 /// 836 /// * collection_id.837 /// 838 /// * address.839 #[weight = <T as Config>::WeightInfo::add_to_white_list()]840 #[transactional]841 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843 let sender = ensure_signed(origin)?;844 let collection = Self::get_collection(collection_id)?;845 Self::check_owner_or_admin_permissions(&collection, sender)?;846847 <WhiteList<T>>::insert(collection_id, address, true);848 849 Ok(())850 }851852 /// Remove an address from white list.853 /// 854 /// # Permissions855 /// 856 /// * Collection Owner857 /// * Collection Admin858 /// 859 /// # Arguments860 /// 861 /// * collection_id.862 /// 863 /// * address.864 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]865 #[transactional]866 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{867868 let sender = ensure_signed(origin)?;869 let collection = Self::get_collection(collection_id)?;870 Self::check_owner_or_admin_permissions(&collection, sender)?;871872 <WhiteList<T>>::remove(collection_id, address);873874 Ok(())875 }876877 /// Toggle between normal and white list access for the methods with access for `Anyone`.878 /// 879 /// # Permissions880 /// 881 /// * Collection Owner.882 /// 883 /// # Arguments884 /// 885 /// * collection_id.886 /// 887 /// * mode: [AccessMode]888 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]889 #[transactional]890 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult891 {892 let sender = ensure_signed(origin)?;893894 let mut target_collection = Self::get_collection(collection_id)?;895 Self::check_owner_permissions(&target_collection, sender)?;896 target_collection.access = mode;897 Self::save_collection(target_collection);898899 Ok(())900 }901902 /// Allows Anyone to create tokens if:903 /// * White List is enabled, and904 /// * Address is added to white list, and905 /// * This method was called with True parameter906 /// 907 /// # Permissions908 /// * Collection Owner909 ///910 /// # Arguments911 /// 912 /// * collection_id.913 /// 914 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.915 #[weight = <T as Config>::WeightInfo::set_mint_permission()]916 #[transactional]917 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult918 {919 let sender = ensure_signed(origin)?;920921 let mut target_collection = Self::get_collection(collection_id)?;922 Self::check_owner_permissions(&target_collection, sender)?;923 target_collection.mint_mode = mint_permission;924 Self::save_collection(target_collection);925926 Ok(())927 }928929 /// Change the owner of the collection.930 /// 931 /// # Permissions932 /// 933 /// * Collection Owner.934 /// 935 /// # Arguments936 /// 937 /// * collection_id.938 /// 939 /// * new_owner.940 #[weight = <T as Config>::WeightInfo::change_collection_owner()]941 #[transactional]942 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {943944 let sender = ensure_signed(origin)?;945 let mut target_collection = Self::get_collection(collection_id)?;946 Self::check_owner_permissions(&target_collection, sender)?;947 target_collection.owner = new_owner;948 Self::save_collection(target_collection);949950 Ok(())951 }952953 /// Adds an admin of the Collection.954 /// 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. 955 /// 956 /// # Permissions957 /// 958 /// * Collection Owner.959 /// * Collection Admin.960 /// 961 /// # Arguments962 /// 963 /// * collection_id: ID of the Collection to add admin for.964 /// 965 /// * new_admin_id: Address of new admin to add.966 #[weight = <T as Config>::WeightInfo::add_collection_admin()]967 #[transactional]968 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {969970 let sender = ensure_signed(origin)?;971 let collection = Self::get_collection(collection_id)?;972 Self::check_owner_or_admin_permissions(&collection, sender)?;973 let mut admin_arr = <AdminList<T>>::get(collection_id);974975 match admin_arr.binary_search(&new_admin_id) {976 Ok(_) => {},977 Err(idx) => {978 let limits = ChainLimit::get();979 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);980 admin_arr.insert(idx, new_admin_id);981 <AdminList<T>>::insert(collection_id, admin_arr);982 }983 }984 Ok(())985 }986987 /// 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.988 ///989 /// # Permissions990 /// 991 /// * Collection Owner.992 /// * Collection Admin.993 /// 994 /// # Arguments995 /// 996 /// * collection_id: ID of the Collection to remove admin for.997 /// 998 /// * account_id: Address of admin to remove.999 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1000 #[transactional]1001 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10021003 let sender = ensure_signed(origin)?;1004 let collection = Self::get_collection(collection_id)?;1005 Self::check_owner_or_admin_permissions(&collection, sender)?;1006 let mut admin_arr = <AdminList<T>>::get(collection_id);10071008 match admin_arr.binary_search(&account_id) {1009 Ok(idx) => {1010 admin_arr.remove(idx);1011 <AdminList<T>>::insert(collection_id, admin_arr);1012 },1013 Err(_) => {}1014 }1015 Ok(())1016 }10171018 /// # Permissions1019 /// 1020 /// * Collection Owner1021 /// 1022 /// # Arguments1023 /// 1024 /// * collection_id.1025 /// 1026 /// * new_sponsor.1027 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1028 #[transactional]1029 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10301031 let sender = ensure_signed(origin)?;1032 let mut target_collection = Self::get_collection(collection_id)?;1033 Self::check_owner_permissions(&target_collection, sender)?;10341035 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1036 Self::save_collection(target_collection);10371038 Ok(())1039 }10401041 /// # Permissions1042 /// 1043 /// * Sponsor.1044 /// 1045 /// # Arguments1046 /// 1047 /// * collection_id.1048 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1049 #[transactional]1050 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10511052 let sender = ensure_signed(origin)?;10531054 let mut target_collection = Self::get_collection(collection_id)?;1055 ensure!(1056 target_collection.sponsorship.pending_sponsor() == Some(&sender),1057 Error::<T>::ConfirmUnsetSponsorFail1058 );10591060 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1061 Self::save_collection(target_collection);10621063 Ok(())1064 }10651066 /// Switch back to pay-per-own-transaction model.1067 ///1068 /// # Permissions1069 ///1070 /// * Collection owner.1071 /// 1072 /// # Arguments1073 /// 1074 /// * collection_id.1075 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1076 #[transactional]1077 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10781079 let sender = ensure_signed(origin)?;10801081 let mut target_collection = Self::get_collection(collection_id)?;1082 Self::check_owner_permissions(&target_collection, sender)?;10831084 target_collection.sponsorship = SponsorshipState::Disabled;1085 Self::save_collection(target_collection);10861087 Ok(())1088 }10891090 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1091 /// 1092 /// # Permissions1093 /// 1094 /// * Collection Owner.1095 /// * Collection Admin.1096 /// * Anyone if1097 /// * White List is enabled, and1098 /// * Address is added to white list, and1099 /// * MintPermission is enabled (see SetMintPermission method)1100 /// 1101 /// # Arguments1102 /// 1103 /// * collection_id: ID of the collection.1104 /// 1105 /// * owner: Address, initial owner of the NFT.1106 ///1107 /// * data: Token data to store on chain.1108 // #[weight =1109 // (130_000_000 as Weight)1110 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1111 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1112 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11131114 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1115 #[transactional]1116 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11171118 let sender = ensure_signed(origin)?;11191120 let target_collection = Self::get_collection(collection_id)?;11211122 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1123 Self::validate_create_item_args(&target_collection, &data)?;1124 Self::create_item_no_validation(&target_collection, owner, data)?;11251126 Ok(())1127 }11281129 /// This method creates multiple items in a collection created with CreateCollection method.1130 /// 1131 /// # Permissions1132 /// 1133 /// * Collection Owner.1134 /// * Collection Admin.1135 /// * Anyone if1136 /// * White List is enabled, and1137 /// * Address is added to white list, and1138 /// * MintPermission is enabled (see SetMintPermission method)1139 /// 1140 /// # Arguments1141 /// 1142 /// * collection_id: ID of the collection.1143 /// 1144 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1145 /// 1146 /// * owner: Address, initial owner of the NFT.1147 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148 .map(|data| { data.len() })1149 .sum())]1150 #[transactional]1151 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154 let sender = ensure_signed(origin)?;11551156 let target_collection = Self::get_collection(collection_id)?;11571158 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160 for data in &items_data {1161 Self::validate_create_item_args(&target_collection, data)?;1162 }1163 for data in &items_data {1164 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165 }11661167 Ok(())1168 }11691170 /// Destroys a concrete instance of NFT.1171 /// 1172 /// # Permissions1173 /// 1174 /// * Collection Owner.1175 /// * Collection Admin.1176 /// * Current NFT Owner.1177 /// 1178 /// # Arguments1179 /// 1180 /// * collection_id: ID of the collection.1181 /// 1182 /// * item_id: ID of NFT to burn.1183 #[weight = <T as Config>::WeightInfo::burn_item()]1184 #[transactional]1185 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187 let sender = ensure_signed(origin)?;11881189 // Transfer permissions check1190 let target_collection = Self::get_collection(collection_id)?;1191 ensure!(1192 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193 (1194 target_collection.limits.owner_can_transfer &&1195 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196 ),1197 Error::<T>::NoPermission1198 );11991200 if target_collection.access == AccessMode::WhiteList {1201 Self::check_white_list(&target_collection, &sender)?;1202 }12031204 match target_collection.mode1205 {1206 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1208 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209 _ => ()1210 };12111212 // call event1213 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215 Ok(())1216 }12171218 /// Change ownership of the token.1219 /// 1220 /// # Permissions1221 /// 1222 /// * Collection Owner1223 /// * Collection Admin1224 /// * Current NFT owner1225 ///1226 /// # Arguments1227 /// 1228 /// * recipient: Address of token recipient.1229 /// 1230 /// * collection_id.1231 /// 1232 /// * item_id: ID of the item1233 /// * Non-Fungible Mode: Required.1234 /// * Fungible Mode: Ignored.1235 /// * Re-Fungible Mode: Required.1236 /// 1237 /// * value: Amount to transfer.1238 /// * Non-Fungible Mode: Ignored1239 /// * Fungible Mode: Must specify transferred amount1240 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1241 #[weight = <T as Config>::WeightInfo::transfer()]1242 #[transactional]1243 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244 let sender = ensure_signed(origin)?;1245 let collection = Self::get_collection(collection_id)?;12461247 Self::transfer_internal(sender, recipient, &collection, item_id, value)1248 }12491250 /// Set, change, or remove approved address to transfer the ownership of the NFT.1251 /// 1252 /// # Permissions1253 /// 1254 /// * Collection Owner1255 /// * Collection Admin1256 /// * Current NFT owner1257 /// 1258 /// # Arguments1259 /// 1260 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1261 /// 1262 /// * collection_id.1263 /// 1264 /// * item_id: ID of the item.1265 #[weight = <T as Config>::WeightInfo::approve()]1266 #[transactional]1267 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269 let sender = ensure_signed(origin)?;1270 let target_collection = Self::get_collection(collection_id)?;12711272 Self::token_exists(&target_collection, item_id)?;12731274 // Transfer permissions check1275 let bypasses_limits = target_collection.limits.owner_can_transfer &&1276 Self::is_owner_or_admin_permissions(1277 &target_collection,1278 sender.clone(),1279 );12801281 let allowance_limit = if bypasses_limits {1282 None1283 } else if let Some(amount) = Self::owned_amount(1284 sender.clone(),1285 &target_collection,1286 item_id,1287 ) {1288 Some(amount)1289 } else {1290 fail!(Error::<T>::NoPermission);1291 };12921293 if target_collection.access == AccessMode::WhiteList {1294 Self::check_white_list(&target_collection, &sender)?;1295 Self::check_white_list(&target_collection, &spender)?;1296 }12971298 let allowance_exists = <Allowances<T>>::contains_key(collection_id, (item_id, &sender, &spender));1299 let mut allowance: u128 = amount;1300 if allowance_exists {1301 allowance += <Allowances<T>>::get(collection_id, (item_id, &sender, &spender));1302 }1303 if let Some(limit) = allowance_limit {1304 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1305 }1306 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13071308 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1309 Ok(())1310 }1311 1312 /// 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.1313 /// 1314 /// # Permissions1315 /// * Collection Owner1316 /// * Collection Admin1317 /// * Current NFT owner1318 /// * Address approved by current NFT owner1319 /// 1320 /// # Arguments1321 /// 1322 /// * from: Address that owns token.1323 /// 1324 /// * recipient: Address of token recipient.1325 /// 1326 /// * collection_id.1327 /// 1328 /// * item_id: ID of the item.1329 /// 1330 /// * value: Amount to transfer.1331 #[weight = <T as Config>::WeightInfo::transfer_from()]1332 #[transactional]1333 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13341335 let sender = ensure_signed(origin)?;1336 let target_collection = Self::get_collection(collection_id)?;13371338 let mut appoved_transfer = false;13391340 // Check approval1341 let mut approval: u128 = 0;1342 if <Allowances<T>>::contains_key(collection_id, (item_id, &from, &sender)) {1343 approval = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));1344 ensure!(approval >= value, Error::<T>::TokenValueNotEnough);1345 appoved_transfer = true;1346 }13471348 // Limits check1349 Self::is_correct_transfer(&target_collection, &recipient)?;13501351 // Transfer permissions check 1352 ensure!(1353 appoved_transfer || 1354 (1355 target_collection.limits.owner_can_transfer &&1356 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1357 ),1358 Error::<T>::NoPermission1359 );13601361 if target_collection.access == AccessMode::WhiteList {1362 Self::check_white_list(&target_collection, &sender)?;1363 Self::check_white_list(&target_collection, &recipient)?;1364 }13651366 // Reduce approval by transferred amount or remove if remaining approval drops to 01367 if approval.saturating_sub(value) > 0 {1368 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1369 }1370 else {1371 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1372 }13731374 match target_collection.mode1375 {1376 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1377 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1378 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1379 _ => ()1380 };13811382 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1383 Ok(())1384 }13851386 // #[weight = 0]1387 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13881389 // // let no_perm_mes = "You do not have permissions to modify this collection";1390 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1391 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1392 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13931394 // // // on_nft_received call13951396 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13971398 // Ok(())1399 // }14001401 /// Set off-chain data schema.1402 /// 1403 /// # Permissions1404 /// 1405 /// * Collection Owner1406 /// * Collection Admin1407 /// 1408 /// # Arguments1409 /// 1410 /// * collection_id.1411 /// 1412 /// * schema: String representing the offchain data schema.1413 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1414 #[transactional]1415 pub fn set_variable_meta_data (1416 origin,1417 collection_id: CollectionId,1418 item_id: TokenId,1419 data: Vec<u8>1420 ) -> DispatchResult {1421 let sender = ensure_signed(origin)?;1422 1423 let target_collection = Self::get_collection(collection_id)?;1424 Self::token_exists(&target_collection, item_id)?;14251426 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14271428 // Modify permissions check1429 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1430 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1431 Error::<T>::NoPermission);14321433 match target_collection.mode1434 {1435 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1436 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1437 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1438 _ => fail!(Error::<T>::UnexpectedCollectionType)1439 };14401441 Ok(())1442 }1443 1444 /// Set schema standard1445 /// ImageURL1446 /// Unique1447 /// 1448 /// # Permissions1449 /// 1450 /// * Collection Owner1451 /// * Collection Admin1452 /// 1453 /// # Arguments1454 /// 1455 /// * collection_id.1456 /// 1457 /// * schema: SchemaVersion: enum1458 #[weight = <T as Config>::WeightInfo::set_schema_version()]1459 #[transactional]1460 pub fn set_schema_version(1461 origin,1462 collection_id: CollectionId,1463 version: SchemaVersion1464 ) -> DispatchResult {1465 let sender = ensure_signed(origin)?;1466 let mut target_collection = Self::get_collection(collection_id)?;1467 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1468 target_collection.schema_version = version;1469 Self::save_collection(target_collection);14701471 Ok(())1472 }14731474 /// Set off-chain data schema.1475 /// 1476 /// # Permissions1477 /// 1478 /// * Collection Owner1479 /// * Collection Admin1480 /// 1481 /// # Arguments1482 /// 1483 /// * collection_id.1484 /// 1485 /// * schema: String representing the offchain data schema.1486 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1487 #[transactional]1488 pub fn set_offchain_schema(1489 origin,1490 collection_id: CollectionId,1491 schema: Vec<u8>1492 ) -> DispatchResult {1493 let sender = ensure_signed(origin)?;1494 let mut target_collection = Self::get_collection(collection_id)?;1495 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14961497 // check schema limit1498 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14991500 target_collection.offchain_schema = schema;1501 Self::save_collection(target_collection);15021503 Ok(())1504 }15051506 /// Set const on-chain data schema.1507 /// 1508 /// # Permissions1509 /// 1510 /// * Collection Owner1511 /// * Collection Admin1512 /// 1513 /// # Arguments1514 /// 1515 /// * collection_id.1516 /// 1517 /// * schema: String representing the const on-chain data schema.1518 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1519 #[transactional]1520 pub fn set_const_on_chain_schema (1521 origin,1522 collection_id: CollectionId,1523 schema: Vec<u8>1524 ) -> DispatchResult {1525 let sender = ensure_signed(origin)?;1526 let mut target_collection = Self::get_collection(collection_id)?;1527 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15281529 // check schema limit1530 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15311532 target_collection.const_on_chain_schema = schema;1533 Self::save_collection(target_collection);15341535 Ok(())1536 }15371538 /// Set variable on-chain data schema.1539 /// 1540 /// # Permissions1541 /// 1542 /// * Collection Owner1543 /// * Collection Admin1544 /// 1545 /// # Arguments1546 /// 1547 /// * collection_id.1548 /// 1549 /// * schema: String representing the variable on-chain data schema.1550 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1551 #[transactional]1552 pub fn set_variable_on_chain_schema (1553 origin,1554 collection_id: CollectionId,1555 schema: Vec<u8>1556 ) -> DispatchResult {1557 let sender = ensure_signed(origin)?;1558 let mut target_collection = Self::get_collection(collection_id)?;1559 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15601561 // check schema limit1562 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15631564 target_collection.variable_on_chain_schema = schema;1565 Self::save_collection(target_collection);15661567 Ok(())1568 }15691570 // Sudo permissions function1571 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1572 #[transactional]1573 pub fn set_chain_limits(1574 origin,1575 limits: ChainLimits1576 ) -> DispatchResult {15771578 #[cfg(not(feature = "runtime-benchmarks"))]1579 ensure_root(origin)?;15801581 <ChainLimit>::put(limits);1582 Ok(())1583 }15841585 /// Enable smart contract self-sponsoring.1586 /// 1587 /// # Permissions1588 /// 1589 /// * Contract Owner1590 /// 1591 /// # Arguments1592 /// 1593 /// * contract address1594 /// * enable flag1595 /// 1596 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1597 #[transactional]1598 pub fn enable_contract_sponsoring(1599 origin,1600 contract_address: T::AccountId,1601 enable: bool1602 ) -> DispatchResult {16031604 let sender = ensure_signed(origin)?;16051606 #[cfg(feature = "runtime-benchmarks")]1607 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16081609 Self::ensure_contract_owned(sender, &contract_address)?;16101611 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1612 Ok(())1613 }16141615 /// Set the rate limit for contract sponsoring to specified number of blocks.1616 /// 1617 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1618 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1619 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1620 /// from contract endowment if there are at least B blocks between such transactions. 1621 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1622 /// 1623 /// # Permissions1624 /// 1625 /// * Contract Owner1626 /// 1627 /// # Arguments1628 /// 1629 /// -`contract_address`: Address of the contract to sponsor1630 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1631 /// 1632 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1633 #[transactional]1634 pub fn set_contract_sponsoring_rate_limit(1635 origin,1636 contract_address: T::AccountId,1637 rate_limit: T::BlockNumber1638 ) -> DispatchResult {1639 let sender = ensure_signed(origin)?;16401641 #[cfg(feature = "runtime-benchmarks")]1642 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16431644 Self::ensure_contract_owned(sender, &contract_address)?;1645 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1646 Ok(())1647 }16481649 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1650 /// 1651 /// # Permissions1652 /// 1653 /// * Address that deployed smart contract.1654 /// 1655 /// # Arguments1656 /// 1657 /// -`contract_address`: Address of the contract.1658 /// 1659 /// - `enable`: . 1660 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1661 #[transactional]1662 pub fn toggle_contract_white_list(1663 origin,1664 contract_address: T::AccountId,1665 enable: bool1666 ) -> DispatchResult {1667 let sender = ensure_signed(origin)?;16681669 #[cfg(feature = "runtime-benchmarks")]1670 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16711672 Self::ensure_contract_owned(sender, &contract_address)?;1673 if enable {1674 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1675 } else {1676 <ContractWhiteListEnabled<T>>::remove(contract_address);1677 }1678 Ok(())1679 }1680 1681 /// Add an address to smart contract white list.1682 /// 1683 /// # Permissions1684 /// 1685 /// * Address that deployed smart contract.1686 /// 1687 /// # Arguments1688 /// 1689 /// -`contract_address`: Address of the contract.1690 ///1691 /// -`account_address`: Address to add.1692 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1693 #[transactional]1694 pub fn add_to_contract_white_list(1695 origin,1696 contract_address: T::AccountId,1697 account_address: T::AccountId1698 ) -> DispatchResult {1699 let sender = ensure_signed(origin)?;17001701 #[cfg(feature = "runtime-benchmarks")]1702 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1703 1704 Self::ensure_contract_owned(sender, &contract_address)?; 1705 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1706 Ok(())1707 }17081709 /// Remove an address from smart contract white list.1710 /// 1711 /// # Permissions1712 /// 1713 /// * Address that deployed smart contract.1714 /// 1715 /// # Arguments1716 /// 1717 /// -`contract_address`: Address of the contract.1718 ///1719 /// -`account_address`: Address to remove.1720 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1721 #[transactional]1722 pub fn remove_from_contract_white_list(1723 origin,1724 contract_address: T::AccountId,1725 account_address: T::AccountId1726 ) -> DispatchResult {1727 let sender = ensure_signed(origin)?;17281729 #[cfg(feature = "runtime-benchmarks")]1730 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17311732 Self::ensure_contract_owned(sender, &contract_address)?;1733 <ContractWhiteList<T>>::remove(contract_address, account_address);1734 Ok(())1735 }17361737 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1738 #[transactional]1739 pub fn set_collection_limits(1740 origin,1741 collection_id: u32,1742 new_limits: CollectionLimits<T::BlockNumber>,1743 ) -> DispatchResult {1744 let sender = ensure_signed(origin)?;1745 let mut target_collection = Self::get_collection(collection_id)?;1746 Self::check_owner_permissions(&target_collection, sender.clone())?;1747 let old_limits = &target_collection.limits;1748 let chain_limits = ChainLimit::get();17491750 // collection bounds1751 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1752 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1753 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1754 Error::<T>::CollectionLimitBoundsExceeded);17551756 // token_limit check prev1757 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1758 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17591760 ensure!(1761 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1762 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1763 Error::<T>::OwnerPermissionsCantBeReverted,1764 );17651766 target_collection.limits = new_limits;1767 Self::save_collection(target_collection);17681769 Ok(())1770 } 1771 }1772}17731774impl<T: Config> Module<T> {17751776 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1777 // Limits check1778 Self::is_correct_transfer(target_collection, &recipient)?;17791780 // Transfer permissions check1781 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1782 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1783 Error::<T>::NoPermission);17841785 if target_collection.access == AccessMode::WhiteList {1786 Self::check_white_list(target_collection, &sender)?;1787 Self::check_white_list(target_collection, &recipient)?;1788 }17891790 match target_collection.mode1791 {1792 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1793 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1794 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1795 _ => ()1796 };17971798 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17991800 Ok(())1801 }180218031804 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1805 let collection_id = collection.id;18061807 // check token limit and account token limit1808 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1809 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1810 1811 Ok(())1812 }18131814 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1815 let collection_id = collection.id;18161817 // check token limit and account token limit1818 let total_items: u32 = ItemListIndex::get(collection_id)1819 .checked_add(amount)1820 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1821 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1822 .checked_add(amount)1823 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1824 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1825 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18261827 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1828 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1829 Self::check_white_list(collection, owner)?;1830 Self::check_white_list(collection, sender)?;1831 }18321833 Ok(())1834 }18351836 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1837 match target_collection.mode1838 {1839 CollectionMode::NFT => {1840 if let CreateItemData::NFT(data) = data {1841 // check sizes1842 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1843 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1844 } else {1845 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1846 }1847 },1848 CollectionMode::Fungible(_) => {1849 if let CreateItemData::Fungible(_) = data {1850 } else {1851 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1852 }1853 },1854 CollectionMode::ReFungible => {1855 if let CreateItemData::ReFungible(data) = data {18561857 // check sizes1858 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1859 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18601861 // Check refungibility limits1862 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1863 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1864 } else {1865 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1866 }1867 },1868 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1869 };18701871 Ok(())1872 }18731874 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1875 match data1876 {1877 CreateItemData::NFT(data) => {1878 let item = NftItemType {1879 owner: owner.clone(),1880 const_data: data.const_data,1881 variable_data: data.variable_data1882 };18831884 Self::add_nft_item(collection, item)?;1885 },1886 CreateItemData::Fungible(data) => {1887 Self::add_fungible_item(collection, &owner, data.value)?;1888 },1889 CreateItemData::ReFungible(data) => {1890 let mut owner_list = Vec::new();1891 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18921893 let item = ReFungibleItemType {1894 owner: owner_list,1895 const_data: data.const_data,1896 variable_data: data.variable_data1897 };18981899 Self::add_refungible_item(collection, item)?;1900 }1901 };19021903 Ok(())1904 }19051906 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1907 let collection_id = collection.id;19081909 // Does new owner already have an account?1910 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19111912 // Mint 1913 let item = FungibleItemType {1914 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1915 };1916 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19171918 // Update balance1919 let new_balance = <Balance<T>>::get(collection_id, owner)1920 .checked_add(value)1921 .ok_or(Error::<T>::NumOverflow)?;1922 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19231924 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1925 Ok(())1926 }19271928 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1929 let collection_id = collection.id;19301931 let current_index = <ItemListIndex>::get(collection_id)1932 .checked_add(1)1933 .ok_or(Error::<T>::NumOverflow)?;1934 let itemcopy = item.clone();19351936 ensure!(1937 item.owner.len() == 1,1938 Error::<T>::BadCreateRefungibleCall,1939 );1940 let item_owner = item.owner.first().expect("only one owner is defined");19411942 let value = item_owner.fraction;1943 let owner = item_owner.owner.clone();19441945 Self::add_token_index(collection_id, current_index, &owner)?;19461947 <ItemListIndex>::insert(collection_id, current_index);1948 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19491950 // Update balance1951 let new_balance = <Balance<T>>::get(collection_id, &owner)1952 .checked_add(value)1953 .ok_or(Error::<T>::NumOverflow)?;1954 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19551956 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1957 Ok(())1958 }19591960 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1961 let collection_id = collection.id;19621963 let current_index = <ItemListIndex>::get(collection_id)1964 .checked_add(1)1965 .ok_or(Error::<T>::NumOverflow)?;19661967 let item_owner = item.owner.clone();1968 Self::add_token_index(collection_id, current_index, &item.owner)?;19691970 <ItemListIndex>::insert(collection_id, current_index);1971 <NftItemList<T>>::insert(collection_id, current_index, item);19721973 // Update balance1974 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1975 .checked_add(1)1976 .ok_or(Error::<T>::NumOverflow)?;1977 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19781979 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1980 Ok(())1981 }19821983 fn burn_refungible_item(1984 collection: &CollectionHandle<T>,1985 item_id: TokenId,1986 owner: &T::AccountId,1987 ) -> DispatchResult {1988 let collection_id = collection.id;19891990 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1991 .ok_or(Error::<T>::TokenNotFound)?;1992 let rft_balance = token1993 .owner1994 .iter()1995 .find(|&i| i.owner == *owner)1996 .ok_or(Error::<T>::TokenNotFound)?;1997 Self::remove_token_index(collection_id, item_id, owner)?;19981999 // update balance2000 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2001 .checked_sub(rft_balance.fraction)2002 .ok_or(Error::<T>::NumOverflow)?;2003 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20042005 // Re-create owners list with sender removed2006 let index = token2007 .owner2008 .iter()2009 .position(|i| i.owner == *owner)2010 .expect("owned item is exists");2011 token.owner.remove(index);2012 let owner_count = token.owner.len();20132014 // Burn the token completely if this was the last (only) owner2015 if owner_count == 0 {2016 <ReFungibleItemList<T>>::remove(collection_id, item_id);2017 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2018 }2019 else {2020 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2021 }20222023 Ok(())2024 }20252026 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2027 let collection_id = collection.id;20282029 let item = <NftItemList<T>>::get(collection_id, item_id)2030 .ok_or(Error::<T>::TokenNotFound)?;2031 Self::remove_token_index(collection_id, item_id, &item.owner)?;20322033 // update balance2034 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2035 .checked_sub(1)2036 .ok_or(Error::<T>::NumOverflow)?;2037 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2038 <NftItemList<T>>::remove(collection_id, item_id);2039 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20402041 Ok(())2042 }20432044 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2045 let collection_id = collection.id;20462047 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2048 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20492050 // update balance2051 let new_balance = <Balance<T>>::get(collection_id, owner)2052 .checked_sub(value)2053 .ok_or(Error::<T>::NumOverflow)?;2054 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20552056 if balance.value - value > 0 {2057 balance.value -= value;2058 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2059 }2060 else {2061 <FungibleItemList<T>>::remove(collection_id, owner);2062 }20632064 Ok(())2065 }20662067 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2068 Ok(<CollectionById<T>>::get(collection_id)2069 .map(|collection| CollectionHandle {2070 id: collection_id,2071 collection2072 })2073 .ok_or(Error::<T>::CollectionNotFound)?)2074 }20752076 fn save_collection(collection: CollectionHandle<T>) {2077 <CollectionById<T>>::insert(collection.id, collection.collection);2078 }20792080 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2081 ensure!(2082 subject == target_collection.owner,2083 Error::<T>::NoPermission2084 );20852086 Ok(())2087 }20882089 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2090 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2091 }20922093 fn check_owner_or_admin_permissions(2094 collection: &CollectionHandle<T>,2095 subject: T::AccountId,2096 ) -> DispatchResult {2097 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20982099 Ok(())2100 }21012102 fn owned_amount(2103 subject: T::AccountId,2104 target_collection: &CollectionHandle<T>,2105 item_id: TokenId,2106 ) -> Option<u128> {2107 let collection_id = target_collection.id;21082109 match target_collection.mode {2110 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2111 .then(|| 1),2112 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2113 .value),2114 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2115 .owner2116 .iter()2117 .find(|i| i.owner == subject)2118 .map(|i| i.fraction),2119 CollectionMode::Invalid => None,2120 }2121 }21222123 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2124 match target_collection.mode {2125 CollectionMode::Fungible(_) => true,2126 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2127 }2128 }21292130 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2131 let collection_id = collection.id;21322133 let mes = Error::<T>::AddresNotInWhiteList;2134 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21352136 Ok(())2137 }21382139 /// Check if token exists. In case of Fungible, check if there is an entry for 2140 /// the owner in fungible balances double map2141 fn token_exists(2142 target_collection: &CollectionHandle<T>,2143 item_id: TokenId,2144 ) -> DispatchResult {2145 let collection_id = target_collection.id;2146 let exists = match target_collection.mode2147 {2148 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2149 CollectionMode::Fungible(_) => true,2150 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2151 _ => false2152 };21532154 ensure!(exists == true, Error::<T>::TokenNotFound);2155 Ok(())2156 }21572158 fn transfer_fungible(2159 collection: &CollectionHandle<T>,2160 value: u128,2161 owner: &T::AccountId,2162 recipient: &T::AccountId,2163 ) -> DispatchResult {2164 let collection_id = collection.id;21652166 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2167 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21682169 // Send balance to recipient (updates balanceOf of recipient)2170 Self::add_fungible_item(collection, recipient, value)?;21712172 // update balanceOf of sender2173 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21742175 // Reduce or remove sender2176 if balance.value == value {2177 <FungibleItemList<T>>::remove(collection_id, owner);2178 }2179 else {2180 balance.value -= value;2181 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2182 }21832184 Ok(())2185 }21862187 fn transfer_refungible(2188 collection: &CollectionHandle<T>,2189 item_id: TokenId,2190 value: u128,2191 owner: T::AccountId,2192 new_owner: T::AccountId,2193 ) -> DispatchResult {2194 let collection_id = collection.id;2195 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2196 .ok_or(Error::<T>::TokenNotFound)?;21972198 let item = full_item2199 .owner2200 .iter()2201 .filter(|i| i.owner == owner)2202 .next()2203 .ok_or(Error::<T>::TokenNotFound)?;2204 let amount = item.fraction;22052206 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22072208 // update balance2209 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2210 .checked_sub(value)2211 .ok_or(Error::<T>::NumOverflow)?;2212 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22132214 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2215 .checked_add(value)2216 .ok_or(Error::<T>::NumOverflow)?;2217 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22182219 let old_owner = item.owner.clone();2220 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22212222 // transfer2223 if amount == value && !new_owner_has_account {2224 // change owner2225 // new owner do not have account2226 let mut new_full_item = full_item.clone();2227 new_full_item2228 .owner2229 .iter_mut()2230 .find(|i| i.owner == owner)2231 .expect("old owner does present in refungible")2232 .owner = new_owner.clone();2233 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22342235 // update index collection2236 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2237 } else {2238 let mut new_full_item = full_item.clone();2239 new_full_item2240 .owner2241 .iter_mut()2242 .find(|i| i.owner == owner)2243 .expect("old owner does present in refungible")2244 .fraction -= value;22452246 // separate amount2247 if new_owner_has_account {2248 // new owner has account2249 new_full_item2250 .owner2251 .iter_mut()2252 .find(|i| i.owner == new_owner)2253 .expect("new owner has account")2254 .fraction += value;2255 } else {2256 // new owner do not have account2257 new_full_item.owner.push(Ownership {2258 owner: new_owner.clone(),2259 fraction: value,2260 });2261 Self::add_token_index(collection_id, item_id, &new_owner)?;2262 }22632264 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2265 }22662267 Ok(())2268 }22692270 fn transfer_nft(2271 collection: &CollectionHandle<T>,2272 item_id: TokenId,2273 sender: T::AccountId,2274 new_owner: T::AccountId,2275 ) -> DispatchResult {2276 let collection_id = collection.id;2277 let mut item = <NftItemList<T>>::get(collection_id, item_id)2278 .ok_or(Error::<T>::TokenNotFound)?;22792280 ensure!(2281 sender == item.owner,2282 Error::<T>::MustBeTokenOwner2283 );22842285 // update balance2286 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2287 .checked_sub(1)2288 .ok_or(Error::<T>::NumOverflow)?;2289 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22902291 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2292 .checked_add(1)2293 .ok_or(Error::<T>::NumOverflow)?;2294 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22952296 // change owner2297 let old_owner = item.owner.clone();2298 item.owner = new_owner.clone();2299 <NftItemList<T>>::insert(collection_id, item_id, item);23002301 // update index collection2302 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23032304 Ok(())2305 }2306 2307 fn set_re_fungible_variable_data(2308 collection: &CollectionHandle<T>,2309 item_id: TokenId,2310 data: Vec<u8>2311 ) -> DispatchResult {2312 let collection_id = collection.id;2313 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2314 .ok_or(Error::<T>::TokenNotFound)?;23152316 item.variable_data = data;23172318 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23192320 Ok(())2321 }23222323 fn set_nft_variable_data(2324 collection: &CollectionHandle<T>,2325 item_id: TokenId,2326 data: Vec<u8>2327 ) -> DispatchResult {2328 let collection_id = collection.id;2329 let mut item = <NftItemList<T>>::get(collection_id, item_id)2330 .ok_or(Error::<T>::TokenNotFound)?;2331 2332 item.variable_data = data;23332334 <NftItemList<T>>::insert(collection_id, item_id, item);2335 2336 Ok(())2337 }23382339 fn init_collection(item: &Collection<T>) {2340 // check params2341 assert!(2342 item.decimal_points <= MAX_DECIMAL_POINTS,2343 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2344 );2345 assert!(2346 item.name.len() <= 64,2347 "Collection name can not be longer than 63 char"2348 );2349 assert!(2350 item.name.len() <= 256,2351 "Collection description can not be longer than 255 char"2352 );2353 assert!(2354 item.token_prefix.len() <= 16,2355 "Token prefix can not be longer than 15 char"2356 );23572358 // Generate next collection ID2359 let next_id = CreatedCollectionCount::get()2360 .checked_add(1)2361 .unwrap();23622363 CreatedCollectionCount::put(next_id);2364 }23652366 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2367 let current_index = <ItemListIndex>::get(collection_id)2368 .checked_add(1)2369 .unwrap();23702371 let item_owner = item.owner.clone();2372 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23732374 <ItemListIndex>::insert(collection_id, current_index);23752376 // Update balance2377 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2378 .checked_add(1)2379 .unwrap();2380 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2381 }23822383 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2384 let current_index = <ItemListIndex>::get(collection_id)2385 .checked_add(1)2386 .unwrap();23872388 Self::add_token_index(collection_id, current_index, owner).unwrap();23892390 <ItemListIndex>::insert(collection_id, current_index);23912392 // Update balance2393 let new_balance = <Balance<T>>::get(collection_id, owner)2394 .checked_add(item.value)2395 .unwrap();2396 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2397 }23982399 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2400 let current_index = <ItemListIndex>::get(collection_id)2401 .checked_add(1)2402 .unwrap();24032404 let value = item.owner.first().unwrap().fraction;2405 let owner = item.owner.first().unwrap().owner.clone();24062407 Self::add_token_index(collection_id, current_index, &owner).unwrap();24082409 <ItemListIndex>::insert(collection_id, current_index);24102411 // Update balance2412 let new_balance = <Balance<T>>::get(collection_id, &owner)2413 .checked_add(value)2414 .unwrap();2415 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2416 }24172418 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2419 // add to account limit2420 if <AccountItemCount<T>>::contains_key(owner) {24212422 // bound Owned tokens by a single address2423 let count = <AccountItemCount<T>>::get(owner);2424 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24252426 <AccountItemCount<T>>::insert(owner.clone(), count2427 .checked_add(1)2428 .ok_or(Error::<T>::NumOverflow)?);2429 }2430 else {2431 <AccountItemCount<T>>::insert(owner.clone(), 1);2432 }24332434 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2435 if list_exists {2436 let mut list = <AddressTokens<T>>::get(collection_id, owner);2437 let item_contains = list.contains(&item_index.clone());24382439 if !item_contains {2440 list.push(item_index.clone());2441 }24422443 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2444 } else {2445 let mut itm = Vec::new();2446 itm.push(item_index.clone());2447 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2448 }24492450 Ok(())2451 }24522453 fn remove_token_index(2454 collection_id: CollectionId,2455 item_index: TokenId,2456 owner: &T::AccountId,2457 ) -> DispatchResult {24582459 // update counter2460 <AccountItemCount<T>>::insert(owner.clone(), 2461 <AccountItemCount<T>>::get(owner)2462 .checked_sub(1)2463 .ok_or(Error::<T>::NumOverflow)?);246424652466 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2467 if list_exists {2468 let mut list = <AddressTokens<T>>::get(collection_id, owner);2469 let item_contains = list.contains(&item_index.clone());24702471 if item_contains {2472 list.retain(|&item| item != item_index);2473 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2474 }2475 }24762477 Ok(())2478 }24792480 fn move_token_index(2481 collection_id: CollectionId,2482 item_index: TokenId,2483 old_owner: &T::AccountId,2484 new_owner: &T::AccountId,2485 ) -> DispatchResult {2486 Self::remove_token_index(collection_id, item_index, old_owner)?;2487 Self::add_token_index(collection_id, item_index, new_owner)?;24882489 Ok(())2490 }2491 2492 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2493 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24942495 Ok(())2496 }2497}24982499////////////////////////////////////////////////////////////////////////////////////////////////////2500// Economic models2501// #region25022503/// Fee multiplier.2504pub type Multiplier = FixedU128;25052506type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25072508/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2509/// in the queue.2510#[derive(Encode, Decode, Clone, Eq, PartialEq)]2511pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25122513impl<T: Config + Send + Sync> sp_std::fmt::Debug 2514 for ChargeTransactionPayment<T>2515{2516 #[cfg(feature = "std")]2517 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2518 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2519 }2520 #[cfg(not(feature = "std"))]2521 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2522 Ok(())2523 }2524}25252526impl<T: Config> ChargeTransactionPayment<T>2527where2528 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2529 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2530 T::AccountId: AsRef<[u8]>,2531 T::AccountId: UncheckedFrom<T::Hash>,2532{2533 fn traditional_fee(2534 len: usize,2535 info: &DispatchInfoOf<T::Call>,2536 tip: BalanceOf<T>,2537 ) -> BalanceOf<T>2538 where2539 T::Call: Dispatchable<Info = DispatchInfo>,2540 {2541 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2542 }25432544 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2545 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2546 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2547 let len_saturation = max_block_length as u64 / (len as u64).max(1);2548 let coefficient: BalanceOf<T> = weight_saturation2549 .min(len_saturation)2550 .saturated_into::<BalanceOf<T>>();2551 final_fee2552 .saturating_mul(coefficient)2553 .saturated_into::<TransactionPriority>()2554 }25552556 fn withdraw_fee(2557 &self,2558 who: &T::AccountId,2559 call: &T::Call,2560 info: &DispatchInfoOf<T::Call>,2561 len: usize,2562 ) -> Result<2563 (2564 BalanceOf<T>,2565 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2566 ),2567 TransactionValidityError,2568 > {2569 let tip = self.0;25702571 let fee = Self::traditional_fee(len, info, tip);25722573 // Only mess with balances if fee is not zero.2574 if fee.is_zero() {2575 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2576 .map(|i| (fee, i));2577 }25782579 // Determine who is paying transaction fee based on ecnomic model2580 // Parse call to extract collection ID and access collection sponsor2581 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2582 Some(Call::create_item(collection_id, _owner, _properties)) => {2583 let collection = <CollectionById<T>>::get(collection_id)?;25842585 // sponsor timeout2586 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25872588 let limit = collection.limits.sponsor_transfer_timeout;2589 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2590 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2591 let limit_time = last_tx_block + limit.into();2592 if block_number <= limit_time {2593 return None;2594 }2595 }2596 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25972598 // check free create limit2599 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2600 collection.sponsorship.sponsor()2601 .cloned()2602 } else {2603 None2604 }2605 }2606 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2607 let collection = <CollectionById<T>>::get(collection_id)?;2608 2609 let mut sponsor_transfer = false;2610 if collection.sponsorship.confirmed() {26112612 let collection_limits = collection.limits;2613 let collection_mode = collection.mode;2614 2615 // sponsor timeout2616 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2617 sponsor_transfer = match collection_mode {2618 CollectionMode::NFT => {2619 2620 // get correct limit2621 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2622 collection_limits.sponsor_transfer_timeout2623 } else {2624 ChainLimit::get().nft_sponsor_transfer_timeout2625 };2626 2627 let mut sponsored = true;2628 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2629 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2630 let limit_time = last_tx_block + limit.into();2631 if block_number <= limit_time {2632 sponsored = false;2633 }2634 }2635 if sponsored {2636 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2637 }26382639 sponsored2640 }2641 CollectionMode::Fungible(_) => {2642 2643 // get correct limit2644 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2645 collection_limits.sponsor_transfer_timeout2646 } else {2647 ChainLimit::get().fungible_sponsor_transfer_timeout2648 };2649 2650 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2651 let mut sponsored = true;2652 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2653 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2654 let limit_time = last_tx_block + limit.into();2655 if block_number <= limit_time {2656 sponsored = false;2657 }2658 }2659 if sponsored {2660 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2661 }26622663 sponsored2664 }2665 CollectionMode::ReFungible => {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().refungible_sponsor_transfer_timeout2672 };2673 2674 let mut sponsored = true;2675 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2676 let last_tx_block = <ReFungibleTransferBasket<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 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2684 }26852686 sponsored2687 }2688 _ => {2689 false2690 },2691 };2692 }26932694 if !sponsor_transfer {2695 None2696 } else {2697 collection.sponsorship.sponsor()2698 .cloned()2699 }2700 }27012702 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2703 let mut sponsor_metadata_changes = false;27042705 let collection = <CollectionById<T>>::get(collection_id)?;27062707 if2708 collection.sponsorship.confirmed() &&2709 // Can't sponsor fungible collection, this tx will be rejected2710 // as invalid2711 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2712 data.len() <= collection.limits.sponsored_data_size as usize2713 {2714 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2715 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27162717 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2718 .map(|last_block| block_number - last_block > rate_limit)2719 .unwrap_or(true) 2720 {2721 sponsor_metadata_changes = true;2722 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2723 }2724 }2725 }27262727 if !sponsor_metadata_changes {2728 None2729 } else {2730 collection.sponsorship.sponsor().cloned()2731 }2732 }27332734 _ => None,2735 })();27362737 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2738 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27392740 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27412742 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2743 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2744 2745 if !owned_contract && white_list_enabled {2746 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2747 return Err(InvalidTransaction::Call.into());2748 }2749 }2750 },2751 _ => {},2752 }27532754 // Sponsor smart contracts2755 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27562757 // On instantiation: set the contract owner2758 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27592760 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2761 &who,2762 code_hash,2763 salt,2764 );2765 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27662767 None2768 },27692770 // On instantiation with code: set the contract owner2771 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27722773 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2774 &who,2775 &T::Hashing::hash(&_code),2776 _salt,2777 );27782779 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27802781 None2782 }27832784 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2785 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 mut sponsor_transfer = false;2790 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2791 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2792 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2793 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2794 let limit_time = last_tx_block + rate_limit;27952796 if block_number >= limit_time {2797 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2798 sponsor_transfer = true;2799 }2800 } else {2801 sponsor_transfer = false;2802 }2803 2804 if sponsor_transfer {2805 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2806 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2807 return Some(called_contract);2808 }2809 }2810 }28112812 None2813 },28142815 _ => None,2816 });28172818 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28192820 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2821 .map(|i| (fee, i))2822 }2823}282428252826impl<T: Config + Send + Sync> SignedExtension2827 for ChargeTransactionPayment<T>2828where2829 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2830 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2831 T::AccountId: AsRef<[u8]>,2832 T::AccountId: UncheckedFrom<T::Hash>,2833{2834 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2835 type AccountId = T::AccountId;2836 type Call = T::Call;2837 type AdditionalSigned = ();2838 type Pre = (2839 // tip2840 BalanceOf<T>,2841 // who pays fee2842 Self::AccountId,2843 // imbalance resulting from withdrawing the fee2844 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2845 );2846 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2847 Ok(())2848 }28492850 fn validate(2851 &self,2852 who: &Self::AccountId,2853 call: &Self::Call,2854 info: &DispatchInfoOf<Self::Call>,2855 len: usize,2856 ) -> TransactionValidity {2857 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2858 Ok(ValidTransaction {2859 priority: Self::get_priority(len, info, fee),2860 ..Default::default()2861 })2862 }28632864 fn pre_dispatch(2865 self,2866 who: &Self::AccountId,2867 call: &Self::Call,2868 info: &DispatchInfoOf<Self::Call>,2869 len: usize,2870 ) -> Result<Self::Pre, TransactionValidityError> {2871 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2872 Ok((self.0, who.clone(), imbalance))2873 }28742875 fn post_dispatch(2876 pre: Self::Pre,2877 info: &DispatchInfoOf<Self::Call>,2878 post_info: &PostDispatchInfoOf<Self::Call>,2879 len: usize,2880 _result: &DispatchResult,2881 ) -> Result<(), TransactionValidityError> {2882 let (tip, who, imbalance) = pre;2883 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2884 len as u32,2885 info,2886 post_info,2887 tip,2888 );2889 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2890 Ok(())2891 }2892}28932894// #endregion