difftreelog
feat approval chain extensions
in: master
2 files changed
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use 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 {1117 let sender = ensure_signed(origin)?;1118 Self::create_item_internal(sender, collection_id, owner, data)1119 }11201121 /// This method creates multiple items in a collection created with CreateCollection method.1122 /// 1123 /// # Permissions1124 /// 1125 /// * Collection Owner.1126 /// * Collection Admin.1127 /// * Anyone if1128 /// * White List is enabled, and1129 /// * Address is added to white list, and1130 /// * MintPermission is enabled (see SetMintPermission method)1131 /// 1132 /// # Arguments1133 /// 1134 /// * collection_id: ID of the collection.1135 /// 1136 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1137 /// 1138 /// * owner: Address, initial owner of the NFT.1139 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1140 .map(|data| { data.len() })1141 .sum())]1142 #[transactional]1143 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11441145 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1146 let sender = ensure_signed(origin)?;11471148 let target_collection = Self::get_collection(collection_id)?;11491150 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11511152 for data in &items_data {1153 Self::validate_create_item_args(&target_collection, data)?;1154 }1155 for data in &items_data {1156 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1157 }11581159 Ok(())1160 }11611162 /// Destroys a concrete instance of NFT.1163 /// 1164 /// # Permissions1165 /// 1166 /// * Collection Owner.1167 /// * Collection Admin.1168 /// * Current NFT Owner.1169 /// 1170 /// # Arguments1171 /// 1172 /// * collection_id: ID of the collection.1173 /// 1174 /// * item_id: ID of NFT to burn.1175 #[weight = <T as Config>::WeightInfo::burn_item()]1176 #[transactional]1177 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11781179 let sender = ensure_signed(origin)?;11801181 // Transfer permissions check1182 let target_collection = Self::get_collection(collection_id)?;1183 ensure!(1184 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1185 (1186 target_collection.limits.owner_can_transfer &&1187 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1188 ),1189 Error::<T>::NoPermission1190 );11911192 if target_collection.access == AccessMode::WhiteList {1193 Self::check_white_list(&target_collection, &sender)?;1194 }11951196 match target_collection.mode1197 {1198 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1199 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1200 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1201 _ => ()1202 };12031204 // call event1205 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12061207 Ok(())1208 }12091210 /// Change ownership of the token.1211 /// 1212 /// # Permissions1213 /// 1214 /// * Collection Owner1215 /// * Collection Admin1216 /// * Current NFT owner1217 ///1218 /// # Arguments1219 /// 1220 /// * recipient: Address of token recipient.1221 /// 1222 /// * collection_id.1223 /// 1224 /// * item_id: ID of the item1225 /// * Non-Fungible Mode: Required.1226 /// * Fungible Mode: Ignored.1227 /// * Re-Fungible Mode: Required.1228 /// 1229 /// * value: Amount to transfer.1230 /// * Non-Fungible Mode: Ignored1231 /// * Fungible Mode: Must specify transferred amount1232 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1233 #[weight = <T as Config>::WeightInfo::transfer()]1234 #[transactional]1235 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1236 let sender = ensure_signed(origin)?;1237 let collection = Self::get_collection(collection_id)?;12381239 Self::transfer_internal(sender, recipient, &collection, item_id, value)1240 }12411242 /// Set, change, or remove approved address to transfer the ownership of the NFT.1243 /// 1244 /// # Permissions1245 /// 1246 /// * Collection Owner1247 /// * Collection Admin1248 /// * Current NFT owner1249 /// 1250 /// # Arguments1251 /// 1252 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1253 /// 1254 /// * collection_id.1255 /// 1256 /// * item_id: ID of the item.1257 #[weight = <T as Config>::WeightInfo::approve()]1258 #[transactional]1259 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12601261 let sender = ensure_signed(origin)?;1262 let target_collection = Self::get_collection(collection_id)?;12631264 Self::token_exists(&target_collection, item_id)?;12651266 // Transfer permissions check1267 let bypasses_limits = target_collection.limits.owner_can_transfer &&1268 Self::is_owner_or_admin_permissions(1269 &target_collection,1270 sender.clone(),1271 );12721273 let allowance_limit = if bypasses_limits {1274 None1275 } else if let Some(amount) = Self::owned_amount(1276 sender.clone(),1277 &target_collection,1278 item_id,1279 ) {1280 Some(amount)1281 } else {1282 fail!(Error::<T>::NoPermission);1283 };12841285 if target_collection.access == AccessMode::WhiteList {1286 Self::check_white_list(&target_collection, &sender)?;1287 Self::check_white_list(&target_collection, &spender)?;1288 }12891290 let allowance: u128 = amount1291 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1292 .ok_or(Error::<T>::NumOverflow)?;1293 if let Some(limit) = allowance_limit {1294 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1295 }1296 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12971298 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1299 Ok(())1300 }1301 1302 /// 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.1303 /// 1304 /// # Permissions1305 /// * Collection Owner1306 /// * Collection Admin1307 /// * Current NFT owner1308 /// * Address approved by current NFT owner1309 /// 1310 /// # Arguments1311 /// 1312 /// * from: Address that owns token.1313 /// 1314 /// * recipient: Address of token recipient.1315 /// 1316 /// * collection_id.1317 /// 1318 /// * item_id: ID of the item.1319 /// 1320 /// * value: Amount to transfer.1321 #[weight = <T as Config>::WeightInfo::transfer_from()]1322 #[transactional]1323 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13241325 let sender = ensure_signed(origin)?;1326 let target_collection = Self::get_collection(collection_id)?;13271328 // Check approval1329 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13301331 // Limits check1332 Self::is_correct_transfer(&target_collection, &recipient)?;13331334 // Transfer permissions check 1335 ensure!(1336 approval >= value || 1337 (1338 target_collection.limits.owner_can_transfer &&1339 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1340 ),1341 Error::<T>::NoPermission1342 );13431344 if target_collection.access == AccessMode::WhiteList {1345 Self::check_white_list(&target_collection, &sender)?;1346 Self::check_white_list(&target_collection, &recipient)?;1347 }13481349 // Reduce approval by transferred amount or remove if remaining approval drops to 01350 if approval.saturating_sub(value) > 0 {1351 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1352 }1353 else {1354 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1355 }13561357 match target_collection.mode1358 {1359 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1360 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1361 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1362 _ => ()1363 };13641365 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1366 Ok(())1367 }13681369 // #[weight = 0]1370 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13711372 // // let no_perm_mes = "You do not have permissions to modify this collection";1373 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1374 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1375 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13761377 // // // on_nft_received call13781379 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13801381 // Ok(())1382 // }13831384 /// Set off-chain data schema.1385 /// 1386 /// # Permissions1387 /// 1388 /// * Collection Owner1389 /// * Collection Admin1390 /// 1391 /// # Arguments1392 /// 1393 /// * collection_id.1394 /// 1395 /// * schema: String representing the offchain data schema.1396 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1397 #[transactional]1398 pub fn set_variable_meta_data (1399 origin,1400 collection_id: CollectionId,1401 item_id: TokenId,1402 data: Vec<u8>1403 ) -> DispatchResult {1404 let sender = ensure_signed(origin)?;1405 1406 let target_collection = Self::get_collection(collection_id)?;1407 Self::token_exists(&target_collection, item_id)?;14081409 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14101411 // Modify permissions check1412 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1413 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1414 Error::<T>::NoPermission);14151416 match target_collection.mode1417 {1418 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1419 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1420 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1421 _ => fail!(Error::<T>::UnexpectedCollectionType)1422 };14231424 Ok(())1425 }1426 1427 /// Set schema standard1428 /// ImageURL1429 /// Unique1430 /// 1431 /// # Permissions1432 /// 1433 /// * Collection Owner1434 /// * Collection Admin1435 /// 1436 /// # Arguments1437 /// 1438 /// * collection_id.1439 /// 1440 /// * schema: SchemaVersion: enum1441 #[weight = <T as Config>::WeightInfo::set_schema_version()]1442 #[transactional]1443 pub fn set_schema_version(1444 origin,1445 collection_id: CollectionId,1446 version: SchemaVersion1447 ) -> DispatchResult {1448 let sender = ensure_signed(origin)?;1449 let mut target_collection = Self::get_collection(collection_id)?;1450 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1451 target_collection.schema_version = version;1452 Self::save_collection(target_collection);14531454 Ok(())1455 }14561457 /// Set off-chain data schema.1458 /// 1459 /// # Permissions1460 /// 1461 /// * Collection Owner1462 /// * Collection Admin1463 /// 1464 /// # Arguments1465 /// 1466 /// * collection_id.1467 /// 1468 /// * schema: String representing the offchain data schema.1469 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1470 #[transactional]1471 pub fn set_offchain_schema(1472 origin,1473 collection_id: CollectionId,1474 schema: Vec<u8>1475 ) -> DispatchResult {1476 let sender = ensure_signed(origin)?;1477 let mut target_collection = Self::get_collection(collection_id)?;1478 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14791480 // check schema limit1481 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14821483 target_collection.offchain_schema = schema;1484 Self::save_collection(target_collection);14851486 Ok(())1487 }14881489 /// Set const on-chain data schema.1490 /// 1491 /// # Permissions1492 /// 1493 /// * Collection Owner1494 /// * Collection Admin1495 /// 1496 /// # Arguments1497 /// 1498 /// * collection_id.1499 /// 1500 /// * schema: String representing the const on-chain data schema.1501 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1502 #[transactional]1503 pub fn set_const_on_chain_schema (1504 origin,1505 collection_id: CollectionId,1506 schema: Vec<u8>1507 ) -> DispatchResult {1508 let sender = ensure_signed(origin)?;1509 let mut target_collection = Self::get_collection(collection_id)?;1510 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15111512 // check schema limit1513 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15141515 target_collection.const_on_chain_schema = schema;1516 Self::save_collection(target_collection);15171518 Ok(())1519 }15201521 /// Set variable on-chain data schema.1522 /// 1523 /// # Permissions1524 /// 1525 /// * Collection Owner1526 /// * Collection Admin1527 /// 1528 /// # Arguments1529 /// 1530 /// * collection_id.1531 /// 1532 /// * schema: String representing the variable on-chain data schema.1533 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1534 #[transactional]1535 pub fn set_variable_on_chain_schema (1536 origin,1537 collection_id: CollectionId,1538 schema: Vec<u8>1539 ) -> DispatchResult {1540 let sender = ensure_signed(origin)?;1541 let mut target_collection = Self::get_collection(collection_id)?;1542 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15431544 // check schema limit1545 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15461547 target_collection.variable_on_chain_schema = schema;1548 Self::save_collection(target_collection);15491550 Ok(())1551 }15521553 // Sudo permissions function1554 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1555 #[transactional]1556 pub fn set_chain_limits(1557 origin,1558 limits: ChainLimits1559 ) -> DispatchResult {15601561 #[cfg(not(feature = "runtime-benchmarks"))]1562 ensure_root(origin)?;15631564 <ChainLimit>::put(limits);1565 Ok(())1566 }15671568 /// Enable smart contract self-sponsoring.1569 /// 1570 /// # Permissions1571 /// 1572 /// * Contract Owner1573 /// 1574 /// # Arguments1575 /// 1576 /// * contract address1577 /// * enable flag1578 /// 1579 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1580 #[transactional]1581 pub fn enable_contract_sponsoring(1582 origin,1583 contract_address: T::AccountId,1584 enable: bool1585 ) -> DispatchResult {15861587 let sender = ensure_signed(origin)?;15881589 #[cfg(feature = "runtime-benchmarks")]1590 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15911592 Self::ensure_contract_owned(sender, &contract_address)?;15931594 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1595 Ok(())1596 }15971598 /// Set the rate limit for contract sponsoring to specified number of blocks.1599 /// 1600 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1601 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1602 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1603 /// from contract endowment if there are at least B blocks between such transactions. 1604 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1605 /// 1606 /// # Permissions1607 /// 1608 /// * Contract Owner1609 /// 1610 /// # Arguments1611 /// 1612 /// -`contract_address`: Address of the contract to sponsor1613 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1614 /// 1615 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1616 #[transactional]1617 pub fn set_contract_sponsoring_rate_limit(1618 origin,1619 contract_address: T::AccountId,1620 rate_limit: T::BlockNumber1621 ) -> DispatchResult {1622 let sender = ensure_signed(origin)?;16231624 #[cfg(feature = "runtime-benchmarks")]1625 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16261627 Self::ensure_contract_owned(sender, &contract_address)?;1628 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1629 Ok(())1630 }16311632 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1633 /// 1634 /// # Permissions1635 /// 1636 /// * Address that deployed smart contract.1637 /// 1638 /// # Arguments1639 /// 1640 /// -`contract_address`: Address of the contract.1641 /// 1642 /// - `enable`: . 1643 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1644 #[transactional]1645 pub fn toggle_contract_white_list(1646 origin,1647 contract_address: T::AccountId,1648 enable: bool1649 ) -> DispatchResult {1650 let sender = ensure_signed(origin)?;16511652 #[cfg(feature = "runtime-benchmarks")]1653 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16541655 Self::ensure_contract_owned(sender, &contract_address)?;1656 if enable {1657 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1658 } else {1659 <ContractWhiteListEnabled<T>>::remove(contract_address);1660 }1661 Ok(())1662 }1663 1664 /// Add an address to smart contract white list.1665 /// 1666 /// # Permissions1667 /// 1668 /// * Address that deployed smart contract.1669 /// 1670 /// # Arguments1671 /// 1672 /// -`contract_address`: Address of the contract.1673 ///1674 /// -`account_address`: Address to add.1675 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1676 #[transactional]1677 pub fn add_to_contract_white_list(1678 origin,1679 contract_address: T::AccountId,1680 account_address: T::AccountId1681 ) -> DispatchResult {1682 let sender = ensure_signed(origin)?;16831684 #[cfg(feature = "runtime-benchmarks")]1685 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1686 1687 Self::ensure_contract_owned(sender, &contract_address)?; 1688 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1689 Ok(())1690 }16911692 /// Remove an address from smart contract white list.1693 /// 1694 /// # Permissions1695 /// 1696 /// * Address that deployed smart contract.1697 /// 1698 /// # Arguments1699 /// 1700 /// -`contract_address`: Address of the contract.1701 ///1702 /// -`account_address`: Address to remove.1703 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1704 #[transactional]1705 pub fn remove_from_contract_white_list(1706 origin,1707 contract_address: T::AccountId,1708 account_address: T::AccountId1709 ) -> DispatchResult {1710 let sender = ensure_signed(origin)?;17111712 #[cfg(feature = "runtime-benchmarks")]1713 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17141715 Self::ensure_contract_owned(sender, &contract_address)?;1716 <ContractWhiteList<T>>::remove(contract_address, account_address);1717 Ok(())1718 }17191720 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1721 #[transactional]1722 pub fn set_collection_limits(1723 origin,1724 collection_id: u32,1725 new_limits: CollectionLimits<T::BlockNumber>,1726 ) -> DispatchResult {1727 let sender = ensure_signed(origin)?;1728 let mut target_collection = Self::get_collection(collection_id)?;1729 Self::check_owner_permissions(&target_collection, sender.clone())?;1730 let old_limits = &target_collection.limits;1731 let chain_limits = ChainLimit::get();17321733 // collection bounds1734 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1735 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1736 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1737 Error::<T>::CollectionLimitBoundsExceeded);17381739 // token_limit check prev1740 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1741 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17421743 ensure!(1744 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1745 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1746 Error::<T>::OwnerPermissionsCantBeReverted,1747 );17481749 target_collection.limits = new_limits;1750 Self::save_collection(target_collection);17511752 Ok(())1753 } 1754 }1755}17561757impl<T: Config> Module<T> {1758 pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1759 let target_collection = Self::get_collection(collection_id)?;17601761 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1762 Self::validate_create_item_args(&target_collection, &data)?;1763 Self::create_item_no_validation(&target_collection, owner, data)?;17641765 Ok(())1766 }17671768 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1769 // Limits check1770 Self::is_correct_transfer(target_collection, &recipient)?;17711772 // Transfer permissions check1773 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1774 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1775 Error::<T>::NoPermission);17761777 if target_collection.access == AccessMode::WhiteList {1778 Self::check_white_list(target_collection, &sender)?;1779 Self::check_white_list(target_collection, &recipient)?;1780 }17811782 match target_collection.mode1783 {1784 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1785 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1786 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1787 _ => ()1788 };17891790 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17911792 Ok(())1793 }17941795 pub fn create_multiple_items_internal(1796 sender: T::AccountId,1797 collection: &CollectionHandle<T>,1798 owner: T::AccountId,1799 items_data: Vec<CreateItemData>,1800 ) -> DispatchResult {1801 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18021803 for data in &items_data {1804 Self::validate_create_item_args(&collection, data)?;1805 }1806 for data in &items_data {1807 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1808 }18091810 Ok(())1811 }18121813 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1814 let collection_id = collection.id;18151816 // check token limit and account token limit1817 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1818 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1819 1820 Ok(())1821 }18221823 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1824 let collection_id = collection.id;18251826 // check token limit and account token limit1827 let total_items: u32 = ItemListIndex::get(collection_id)1828 .checked_add(amount)1829 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1830 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1831 .checked_add(amount)1832 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1833 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1834 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18351836 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1837 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1838 Self::check_white_list(collection, owner)?;1839 Self::check_white_list(collection, sender)?;1840 }18411842 Ok(())1843 }18441845 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1846 match target_collection.mode1847 {1848 CollectionMode::NFT => {1849 if let CreateItemData::NFT(data) = data {1850 // check sizes1851 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1852 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1853 } else {1854 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1855 }1856 },1857 CollectionMode::Fungible(_) => {1858 if let CreateItemData::Fungible(_) = data {1859 } else {1860 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1861 }1862 },1863 CollectionMode::ReFungible => {1864 if let CreateItemData::ReFungible(data) = data {18651866 // check sizes1867 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1868 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18691870 // Check refungibility limits1871 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1872 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1873 } else {1874 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1875 }1876 },1877 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1878 };18791880 Ok(())1881 }18821883 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1884 match data1885 {1886 CreateItemData::NFT(data) => {1887 let item = NftItemType {1888 owner: owner.clone(),1889 const_data: data.const_data,1890 variable_data: data.variable_data1891 };18921893 Self::add_nft_item(collection, item)?;1894 },1895 CreateItemData::Fungible(data) => {1896 Self::add_fungible_item(collection, &owner, data.value)?;1897 },1898 CreateItemData::ReFungible(data) => {1899 let mut owner_list = Vec::new();1900 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19011902 let item = ReFungibleItemType {1903 owner: owner_list,1904 const_data: data.const_data,1905 variable_data: data.variable_data1906 };19071908 Self::add_refungible_item(collection, item)?;1909 }1910 };19111912 Ok(())1913 }19141915 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1916 let collection_id = collection.id;19171918 // Does new owner already have an account?1919 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19201921 // Mint 1922 let item = FungibleItemType {1923 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1924 };1925 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19261927 // Update balance1928 let new_balance = <Balance<T>>::get(collection_id, owner)1929 .checked_add(value)1930 .ok_or(Error::<T>::NumOverflow)?;1931 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19321933 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1934 Ok(())1935 }19361937 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1938 let collection_id = collection.id;19391940 let current_index = <ItemListIndex>::get(collection_id)1941 .checked_add(1)1942 .ok_or(Error::<T>::NumOverflow)?;1943 let itemcopy = item.clone();19441945 ensure!(1946 item.owner.len() == 1,1947 Error::<T>::BadCreateRefungibleCall,1948 );1949 let item_owner = item.owner.first().expect("only one owner is defined");19501951 let value = item_owner.fraction;1952 let owner = item_owner.owner.clone();19531954 Self::add_token_index(collection_id, current_index, &owner)?;19551956 <ItemListIndex>::insert(collection_id, current_index);1957 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19581959 // Update balance1960 let new_balance = <Balance<T>>::get(collection_id, &owner)1961 .checked_add(value)1962 .ok_or(Error::<T>::NumOverflow)?;1963 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19641965 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1966 Ok(())1967 }19681969 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1970 let collection_id = collection.id;19711972 let current_index = <ItemListIndex>::get(collection_id)1973 .checked_add(1)1974 .ok_or(Error::<T>::NumOverflow)?;19751976 let item_owner = item.owner.clone();1977 Self::add_token_index(collection_id, current_index, &item.owner)?;19781979 <ItemListIndex>::insert(collection_id, current_index);1980 <NftItemList<T>>::insert(collection_id, current_index, item);19811982 // Update balance1983 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1984 .checked_add(1)1985 .ok_or(Error::<T>::NumOverflow)?;1986 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19871988 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1989 Ok(())1990 }19911992 fn burn_refungible_item(1993 collection: &CollectionHandle<T>,1994 item_id: TokenId,1995 owner: &T::AccountId,1996 ) -> DispatchResult {1997 let collection_id = collection.id;19981999 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2000 .ok_or(Error::<T>::TokenNotFound)?;2001 let rft_balance = token2002 .owner2003 .iter()2004 .find(|&i| i.owner == *owner)2005 .ok_or(Error::<T>::TokenNotFound)?;2006 Self::remove_token_index(collection_id, item_id, owner)?;20072008 // update balance2009 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2010 .checked_sub(rft_balance.fraction)2011 .ok_or(Error::<T>::NumOverflow)?;2012 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20132014 // Re-create owners list with sender removed2015 let index = token2016 .owner2017 .iter()2018 .position(|i| i.owner == *owner)2019 .expect("owned item is exists");2020 token.owner.remove(index);2021 let owner_count = token.owner.len();20222023 // Burn the token completely if this was the last (only) owner2024 if owner_count == 0 {2025 <ReFungibleItemList<T>>::remove(collection_id, item_id);2026 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2027 }2028 else {2029 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2030 }20312032 Ok(())2033 }20342035 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2036 let collection_id = collection.id;20372038 let item = <NftItemList<T>>::get(collection_id, item_id)2039 .ok_or(Error::<T>::TokenNotFound)?;2040 Self::remove_token_index(collection_id, item_id, &item.owner)?;20412042 // update balance2043 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2044 .checked_sub(1)2045 .ok_or(Error::<T>::NumOverflow)?;2046 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2047 <NftItemList<T>>::remove(collection_id, item_id);2048 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20492050 Ok(())2051 }20522053 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2054 let collection_id = collection.id;20552056 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2057 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20582059 // update balance2060 let new_balance = <Balance<T>>::get(collection_id, owner)2061 .checked_sub(value)2062 .ok_or(Error::<T>::NumOverflow)?;2063 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20642065 if balance.value - value > 0 {2066 balance.value -= value;2067 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2068 }2069 else {2070 <FungibleItemList<T>>::remove(collection_id, owner);2071 }20722073 Ok(())2074 }20752076 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2077 Ok(<CollectionById<T>>::get(collection_id)2078 .map(|collection| CollectionHandle {2079 id: collection_id,2080 collection2081 })2082 .ok_or(Error::<T>::CollectionNotFound)?)2083 }20842085 fn save_collection(collection: CollectionHandle<T>) {2086 <CollectionById<T>>::insert(collection.id, collection.collection);2087 }20882089 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2090 ensure!(2091 subject == target_collection.owner,2092 Error::<T>::NoPermission2093 );20942095 Ok(())2096 }20972098 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2099 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2100 }21012102 fn check_owner_or_admin_permissions(2103 collection: &CollectionHandle<T>,2104 subject: T::AccountId,2105 ) -> DispatchResult {2106 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21072108 Ok(())2109 }21102111 fn owned_amount(2112 subject: T::AccountId,2113 target_collection: &CollectionHandle<T>,2114 item_id: TokenId,2115 ) -> Option<u128> {2116 let collection_id = target_collection.id;21172118 match target_collection.mode {2119 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2120 .then(|| 1),2121 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2122 .value),2123 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2124 .owner2125 .iter()2126 .find(|i| i.owner == subject)2127 .map(|i| i.fraction),2128 CollectionMode::Invalid => None,2129 }2130 }21312132 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2133 match target_collection.mode {2134 CollectionMode::Fungible(_) => true,2135 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2136 }2137 }21382139 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2140 let collection_id = collection.id;21412142 let mes = Error::<T>::AddresNotInWhiteList;2143 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21442145 Ok(())2146 }21472148 /// Check if token exists. In case of Fungible, check if there is an entry for 2149 /// the owner in fungible balances double map2150 fn token_exists(2151 target_collection: &CollectionHandle<T>,2152 item_id: TokenId,2153 ) -> DispatchResult {2154 let collection_id = target_collection.id;2155 let exists = match target_collection.mode2156 {2157 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2158 CollectionMode::Fungible(_) => true,2159 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2160 _ => false2161 };21622163 ensure!(exists == true, Error::<T>::TokenNotFound);2164 Ok(())2165 }21662167 fn transfer_fungible(2168 collection: &CollectionHandle<T>,2169 value: u128,2170 owner: &T::AccountId,2171 recipient: &T::AccountId,2172 ) -> DispatchResult {2173 let collection_id = collection.id;21742175 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2176 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21772178 // Send balance to recipient (updates balanceOf of recipient)2179 Self::add_fungible_item(collection, recipient, value)?;21802181 // update balanceOf of sender2182 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21832184 // Reduce or remove sender2185 if balance.value == value {2186 <FungibleItemList<T>>::remove(collection_id, owner);2187 }2188 else {2189 balance.value -= value;2190 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2191 }21922193 Ok(())2194 }21952196 fn transfer_refungible(2197 collection: &CollectionHandle<T>,2198 item_id: TokenId,2199 value: u128,2200 owner: T::AccountId,2201 new_owner: T::AccountId,2202 ) -> DispatchResult {2203 let collection_id = collection.id;2204 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2205 .ok_or(Error::<T>::TokenNotFound)?;22062207 let item = full_item2208 .owner2209 .iter()2210 .filter(|i| i.owner == owner)2211 .next()2212 .ok_or(Error::<T>::TokenNotFound)?;2213 let amount = item.fraction;22142215 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22162217 // update balance2218 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2219 .checked_sub(value)2220 .ok_or(Error::<T>::NumOverflow)?;2221 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22222223 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2224 .checked_add(value)2225 .ok_or(Error::<T>::NumOverflow)?;2226 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22272228 let old_owner = item.owner.clone();2229 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22302231 // transfer2232 if amount == value && !new_owner_has_account {2233 // change owner2234 // new owner do not have account2235 let mut new_full_item = full_item.clone();2236 new_full_item2237 .owner2238 .iter_mut()2239 .find(|i| i.owner == owner)2240 .expect("old owner does present in refungible")2241 .owner = new_owner.clone();2242 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22432244 // update index collection2245 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2246 } else {2247 let mut new_full_item = full_item.clone();2248 new_full_item2249 .owner2250 .iter_mut()2251 .find(|i| i.owner == owner)2252 .expect("old owner does present in refungible")2253 .fraction -= value;22542255 // separate amount2256 if new_owner_has_account {2257 // new owner has account2258 new_full_item2259 .owner2260 .iter_mut()2261 .find(|i| i.owner == new_owner)2262 .expect("new owner has account")2263 .fraction += value;2264 } else {2265 // new owner do not have account2266 new_full_item.owner.push(Ownership {2267 owner: new_owner.clone(),2268 fraction: value,2269 });2270 Self::add_token_index(collection_id, item_id, &new_owner)?;2271 }22722273 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2274 }22752276 Ok(())2277 }22782279 fn transfer_nft(2280 collection: &CollectionHandle<T>,2281 item_id: TokenId,2282 sender: T::AccountId,2283 new_owner: T::AccountId,2284 ) -> DispatchResult {2285 let collection_id = collection.id;2286 let mut item = <NftItemList<T>>::get(collection_id, item_id)2287 .ok_or(Error::<T>::TokenNotFound)?;22882289 ensure!(2290 sender == item.owner,2291 Error::<T>::MustBeTokenOwner2292 );22932294 // update balance2295 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2296 .checked_sub(1)2297 .ok_or(Error::<T>::NumOverflow)?;2298 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22992300 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2301 .checked_add(1)2302 .ok_or(Error::<T>::NumOverflow)?;2303 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23042305 // change owner2306 let old_owner = item.owner.clone();2307 item.owner = new_owner.clone();2308 <NftItemList<T>>::insert(collection_id, item_id, item);23092310 // update index collection2311 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23122313 Ok(())2314 }2315 2316 fn set_re_fungible_variable_data(2317 collection: &CollectionHandle<T>,2318 item_id: TokenId,2319 data: Vec<u8>2320 ) -> DispatchResult {2321 let collection_id = collection.id;2322 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2323 .ok_or(Error::<T>::TokenNotFound)?;23242325 item.variable_data = data;23262327 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23282329 Ok(())2330 }23312332 fn set_nft_variable_data(2333 collection: &CollectionHandle<T>,2334 item_id: TokenId,2335 data: Vec<u8>2336 ) -> DispatchResult {2337 let collection_id = collection.id;2338 let mut item = <NftItemList<T>>::get(collection_id, item_id)2339 .ok_or(Error::<T>::TokenNotFound)?;2340 2341 item.variable_data = data;23422343 <NftItemList<T>>::insert(collection_id, item_id, item);2344 2345 Ok(())2346 }23472348 fn init_collection(item: &Collection<T>) {2349 // check params2350 assert!(2351 item.decimal_points <= MAX_DECIMAL_POINTS,2352 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2353 );2354 assert!(2355 item.name.len() <= 64,2356 "Collection name can not be longer than 63 char"2357 );2358 assert!(2359 item.name.len() <= 256,2360 "Collection description can not be longer than 255 char"2361 );2362 assert!(2363 item.token_prefix.len() <= 16,2364 "Token prefix can not be longer than 15 char"2365 );23662367 // Generate next collection ID2368 let next_id = CreatedCollectionCount::get()2369 .checked_add(1)2370 .unwrap();23712372 CreatedCollectionCount::put(next_id);2373 }23742375 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2376 let current_index = <ItemListIndex>::get(collection_id)2377 .checked_add(1)2378 .unwrap();23792380 let item_owner = item.owner.clone();2381 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23822383 <ItemListIndex>::insert(collection_id, current_index);23842385 // Update balance2386 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2387 .checked_add(1)2388 .unwrap();2389 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2390 }23912392 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2393 let current_index = <ItemListIndex>::get(collection_id)2394 .checked_add(1)2395 .unwrap();23962397 Self::add_token_index(collection_id, current_index, owner).unwrap();23982399 <ItemListIndex>::insert(collection_id, current_index);24002401 // Update balance2402 let new_balance = <Balance<T>>::get(collection_id, owner)2403 .checked_add(item.value)2404 .unwrap();2405 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2406 }24072408 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2409 let current_index = <ItemListIndex>::get(collection_id)2410 .checked_add(1)2411 .unwrap();24122413 let value = item.owner.first().unwrap().fraction;2414 let owner = item.owner.first().unwrap().owner.clone();24152416 Self::add_token_index(collection_id, current_index, &owner).unwrap();24172418 <ItemListIndex>::insert(collection_id, current_index);24192420 // Update balance2421 let new_balance = <Balance<T>>::get(collection_id, &owner)2422 .checked_add(value)2423 .unwrap();2424 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2425 }24262427 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2428 // add to account limit2429 if <AccountItemCount<T>>::contains_key(owner) {24302431 // bound Owned tokens by a single address2432 let count = <AccountItemCount<T>>::get(owner);2433 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24342435 <AccountItemCount<T>>::insert(owner.clone(), count2436 .checked_add(1)2437 .ok_or(Error::<T>::NumOverflow)?);2438 }2439 else {2440 <AccountItemCount<T>>::insert(owner.clone(), 1);2441 }24422443 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2444 if list_exists {2445 let mut list = <AddressTokens<T>>::get(collection_id, owner);2446 let item_contains = list.contains(&item_index.clone());24472448 if !item_contains {2449 list.push(item_index.clone());2450 }24512452 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2453 } else {2454 let mut itm = Vec::new();2455 itm.push(item_index.clone());2456 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2457 }24582459 Ok(())2460 }24612462 fn remove_token_index(2463 collection_id: CollectionId,2464 item_index: TokenId,2465 owner: &T::AccountId,2466 ) -> DispatchResult {24672468 // update counter2469 <AccountItemCount<T>>::insert(owner.clone(), 2470 <AccountItemCount<T>>::get(owner)2471 .checked_sub(1)2472 .ok_or(Error::<T>::NumOverflow)?);247324742475 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2476 if list_exists {2477 let mut list = <AddressTokens<T>>::get(collection_id, owner);2478 let item_contains = list.contains(&item_index.clone());24792480 if item_contains {2481 list.retain(|&item| item != item_index);2482 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2483 }2484 }24852486 Ok(())2487 }24882489 fn move_token_index(2490 collection_id: CollectionId,2491 item_index: TokenId,2492 old_owner: &T::AccountId,2493 new_owner: &T::AccountId,2494 ) -> DispatchResult {2495 Self::remove_token_index(collection_id, item_index, old_owner)?;2496 Self::add_token_index(collection_id, item_index, new_owner)?;24972498 Ok(())2499 }2500 2501 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2502 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25032504 Ok(())2505 }2506}25072508////////////////////////////////////////////////////////////////////////////////////////////////////2509// Economic models2510// #region25112512/// Fee multiplier.2513pub type Multiplier = FixedU128;25142515type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25162517/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2518/// in the queue.2519#[derive(Encode, Decode, Clone, Eq, PartialEq)]2520pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25212522impl<T: Config + Send + Sync> sp_std::fmt::Debug 2523 for ChargeTransactionPayment<T>2524{2525 #[cfg(feature = "std")]2526 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2527 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2528 }2529 #[cfg(not(feature = "std"))]2530 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2531 Ok(())2532 }2533}25342535impl<T: Config> ChargeTransactionPayment<T>2536where2537 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2538 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2539 T::AccountId: AsRef<[u8]>,2540 T::AccountId: UncheckedFrom<T::Hash>,2541{2542 fn traditional_fee(2543 len: usize,2544 info: &DispatchInfoOf<T::Call>,2545 tip: BalanceOf<T>,2546 ) -> BalanceOf<T>2547 where2548 T::Call: Dispatchable<Info = DispatchInfo>,2549 {2550 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2551 }25522553 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2554 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2555 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2556 let len_saturation = max_block_length as u64 / (len as u64).max(1);2557 let coefficient: BalanceOf<T> = weight_saturation2558 .min(len_saturation)2559 .saturated_into::<BalanceOf<T>>();2560 final_fee2561 .saturating_mul(coefficient)2562 .saturated_into::<TransactionPriority>()2563 }25642565 fn withdraw_fee(2566 &self,2567 who: &T::AccountId,2568 call: &T::Call,2569 info: &DispatchInfoOf<T::Call>,2570 len: usize,2571 ) -> Result<2572 (2573 BalanceOf<T>,2574 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2575 ),2576 TransactionValidityError,2577 > {2578 let tip = self.0;25792580 let fee = Self::traditional_fee(len, info, tip);25812582 // Only mess with balances if fee is not zero.2583 if fee.is_zero() {2584 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2585 .map(|i| (fee, i));2586 }25872588 // Determine who is paying transaction fee based on ecnomic model2589 // Parse call to extract collection ID and access collection sponsor2590 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2591 Some(Call::create_item(collection_id, _owner, _properties)) => {2592 let collection = <CollectionById<T>>::get(collection_id)?;25932594 // sponsor timeout2595 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25962597 let limit = collection.limits.sponsor_transfer_timeout;2598 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2599 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2600 let limit_time = last_tx_block + limit.into();2601 if block_number <= limit_time {2602 return None;2603 }2604 }2605 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26062607 // check free create limit2608 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2609 collection.sponsorship.sponsor()2610 .cloned()2611 } else {2612 None2613 }2614 }2615 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2616 let collection = <CollectionById<T>>::get(collection_id)?;2617 2618 let mut sponsor_transfer = false;2619 if collection.sponsorship.confirmed() {26202621 let collection_limits = collection.limits;2622 let collection_mode = collection.mode;2623 2624 // sponsor timeout2625 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2626 sponsor_transfer = match collection_mode {2627 CollectionMode::NFT => {2628 2629 // get correct limit2630 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2631 collection_limits.sponsor_transfer_timeout2632 } else {2633 ChainLimit::get().nft_sponsor_transfer_timeout2634 };2635 2636 let mut sponsored = true;2637 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2638 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2639 let limit_time = last_tx_block + limit.into();2640 if block_number <= limit_time {2641 sponsored = false;2642 }2643 }2644 if sponsored {2645 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2646 }26472648 sponsored2649 }2650 CollectionMode::Fungible(_) => {2651 2652 // get correct limit2653 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2654 collection_limits.sponsor_transfer_timeout2655 } else {2656 ChainLimit::get().fungible_sponsor_transfer_timeout2657 };2658 2659 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2660 let mut sponsored = true;2661 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2662 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2663 let limit_time = last_tx_block + limit.into();2664 if block_number <= limit_time {2665 sponsored = false;2666 }2667 }2668 if sponsored {2669 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2670 }26712672 sponsored2673 }2674 CollectionMode::ReFungible => {2675 2676 // get correct limit2677 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2678 collection_limits.sponsor_transfer_timeout2679 } else {2680 ChainLimit::get().refungible_sponsor_transfer_timeout2681 };2682 2683 let mut sponsored = true;2684 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2685 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2686 let limit_time = last_tx_block + limit.into();2687 if block_number <= limit_time {2688 sponsored = false;2689 }2690 }2691 if sponsored {2692 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2693 }26942695 sponsored2696 }2697 _ => {2698 false2699 },2700 };2701 }27022703 if !sponsor_transfer {2704 None2705 } else {2706 collection.sponsorship.sponsor()2707 .cloned()2708 }2709 }27102711 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2712 let mut sponsor_metadata_changes = false;27132714 let collection = <CollectionById<T>>::get(collection_id)?;27152716 if2717 collection.sponsorship.confirmed() &&2718 // Can't sponsor fungible collection, this tx will be rejected2719 // as invalid2720 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2721 data.len() <= collection.limits.sponsored_data_size as usize2722 {2723 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2724 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27252726 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2727 .map(|last_block| block_number - last_block > rate_limit)2728 .unwrap_or(true) 2729 {2730 sponsor_metadata_changes = true;2731 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2732 }2733 }2734 }27352736 if !sponsor_metadata_changes {2737 None2738 } else {2739 collection.sponsorship.sponsor().cloned()2740 }2741 }27422743 _ => None,2744 })();27452746 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2747 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27482749 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27502751 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2752 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2753 2754 if !owned_contract && white_list_enabled {2755 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2756 return Err(InvalidTransaction::Call.into());2757 }2758 }2759 },2760 _ => {},2761 }27622763 // Sponsor smart contracts2764 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27652766 // On instantiation: set the contract owner2767 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27682769 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2770 &who,2771 code_hash,2772 salt,2773 );2774 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27752776 None2777 },27782779 // On instantiation with code: set the contract owner2780 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27812782 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2783 &who,2784 &T::Hashing::hash(&_code),2785 _salt,2786 );27872788 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27892790 None2791 }27922793 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2794 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27952796 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27972798 let mut sponsor_transfer = false;2799 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2800 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2801 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2802 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2803 let limit_time = last_tx_block + rate_limit;28042805 if block_number >= limit_time {2806 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2807 sponsor_transfer = true;2808 }2809 } else {2810 sponsor_transfer = false;2811 }2812 2813 if sponsor_transfer {2814 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2815 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2816 return Some(called_contract);2817 }2818 }2819 }28202821 None2822 },28232824 _ => None,2825 });28262827 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28282829 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2830 .map(|i| (fee, i))2831 }2832}283328342835impl<T: Config + Send + Sync> SignedExtension2836 for ChargeTransactionPayment<T>2837where2838 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2839 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2840 T::AccountId: AsRef<[u8]>,2841 T::AccountId: UncheckedFrom<T::Hash>,2842{2843 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2844 type AccountId = T::AccountId;2845 type Call = T::Call;2846 type AdditionalSigned = ();2847 type Pre = (2848 // tip2849 BalanceOf<T>,2850 // who pays fee2851 Self::AccountId,2852 // imbalance resulting from withdrawing the fee2853 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2854 );2855 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2856 Ok(())2857 }28582859 fn validate(2860 &self,2861 who: &Self::AccountId,2862 call: &Self::Call,2863 info: &DispatchInfoOf<Self::Call>,2864 len: usize,2865 ) -> TransactionValidity {2866 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2867 Ok(ValidTransaction {2868 priority: Self::get_priority(len, info, fee),2869 ..Default::default()2870 })2871 }28722873 fn pre_dispatch(2874 self,2875 who: &Self::AccountId,2876 call: &Self::Call,2877 info: &DispatchInfoOf<Self::Call>,2878 len: usize,2879 ) -> Result<Self::Pre, TransactionValidityError> {2880 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2881 Ok((self.0, who.clone(), imbalance))2882 }28832884 fn post_dispatch(2885 pre: Self::Pre,2886 info: &DispatchInfoOf<Self::Call>,2887 post_info: &PostDispatchInfoOf<Self::Call>,2888 len: usize,2889 _result: &DispatchResult,2890 ) -> Result<(), TransactionValidityError> {2891 let (tip, who, imbalance) = pre;2892 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2893 len as u32,2894 info,2895 post_info,2896 tip,2897 );2898 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2899 Ok(())2900 }2901}29022903// #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 {1117 let sender = ensure_signed(origin)?;1118 Self::create_item_internal(sender, collection_id, owner, data)1119 }11201121 /// This method creates multiple items in a collection created with CreateCollection method.1122 /// 1123 /// # Permissions1124 /// 1125 /// * Collection Owner.1126 /// * Collection Admin.1127 /// * Anyone if1128 /// * White List is enabled, and1129 /// * Address is added to white list, and1130 /// * MintPermission is enabled (see SetMintPermission method)1131 /// 1132 /// # Arguments1133 /// 1134 /// * collection_id: ID of the collection.1135 /// 1136 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1137 /// 1138 /// * owner: Address, initial owner of the NFT.1139 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1140 .map(|data| { data.len() })1141 .sum())]1142 #[transactional]1143 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11441145 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1146 let sender = ensure_signed(origin)?;11471148 let target_collection = Self::get_collection(collection_id)?;11491150 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11511152 for data in &items_data {1153 Self::validate_create_item_args(&target_collection, data)?;1154 }1155 for data in &items_data {1156 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1157 }11581159 Ok(())1160 }11611162 /// Destroys a concrete instance of NFT.1163 /// 1164 /// # Permissions1165 /// 1166 /// * Collection Owner.1167 /// * Collection Admin.1168 /// * Current NFT Owner.1169 /// 1170 /// # Arguments1171 /// 1172 /// * collection_id: ID of the collection.1173 /// 1174 /// * item_id: ID of NFT to burn.1175 #[weight = <T as Config>::WeightInfo::burn_item()]1176 #[transactional]1177 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11781179 let sender = ensure_signed(origin)?;11801181 // Transfer permissions check1182 let target_collection = Self::get_collection(collection_id)?;1183 ensure!(1184 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1185 (1186 target_collection.limits.owner_can_transfer &&1187 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1188 ),1189 Error::<T>::NoPermission1190 );11911192 if target_collection.access == AccessMode::WhiteList {1193 Self::check_white_list(&target_collection, &sender)?;1194 }11951196 match target_collection.mode1197 {1198 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1199 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1200 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1201 _ => ()1202 };12031204 // call event1205 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12061207 Ok(())1208 }12091210 /// Change ownership of the token.1211 /// 1212 /// # Permissions1213 /// 1214 /// * Collection Owner1215 /// * Collection Admin1216 /// * Current NFT owner1217 ///1218 /// # Arguments1219 /// 1220 /// * recipient: Address of token recipient.1221 /// 1222 /// * collection_id.1223 /// 1224 /// * item_id: ID of the item1225 /// * Non-Fungible Mode: Required.1226 /// * Fungible Mode: Ignored.1227 /// * Re-Fungible Mode: Required.1228 /// 1229 /// * value: Amount to transfer.1230 /// * Non-Fungible Mode: Ignored1231 /// * Fungible Mode: Must specify transferred amount1232 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1233 #[weight = <T as Config>::WeightInfo::transfer()]1234 #[transactional]1235 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1236 let sender = ensure_signed(origin)?;1237 let collection = Self::get_collection(collection_id)?;12381239 Self::transfer_internal(sender, recipient, &collection, item_id, value)1240 }12411242 /// Set, change, or remove approved address to transfer the ownership of the NFT.1243 /// 1244 /// # Permissions1245 /// 1246 /// * Collection Owner1247 /// * Collection Admin1248 /// * Current NFT owner1249 /// 1250 /// # Arguments1251 /// 1252 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1253 /// 1254 /// * collection_id.1255 /// 1256 /// * item_id: ID of the item.1257 #[weight = <T as Config>::WeightInfo::approve()]1258 #[transactional]1259 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12601261 let sender = ensure_signed(origin)?;1262 let collection = Self::get_collection(collection_id)?;12631264 Self::approve_internal(sender, spender, &collection, item_id, amount)?;12651266 Ok(())1267 }1268 1269 /// 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.1270 /// 1271 /// # Permissions1272 /// * Collection Owner1273 /// * Collection Admin1274 /// * Current NFT owner1275 /// * Address approved by current NFT owner1276 /// 1277 /// # Arguments1278 /// 1279 /// * from: Address that owns token.1280 /// 1281 /// * recipient: Address of token recipient.1282 /// 1283 /// * collection_id.1284 /// 1285 /// * item_id: ID of the item.1286 /// 1287 /// * value: Amount to transfer.1288 #[weight = <T as Config>::WeightInfo::transfer_from()]1289 #[transactional]1290 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12911292 let sender = ensure_signed(origin)?;1293 let collection = Self::get_collection(collection_id)?;12941295 Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;12961297 Ok(())1298 }12991300 // #[weight = 0]1301 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13021303 // // let no_perm_mes = "You do not have permissions to modify this collection";1304 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1305 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1306 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13071308 // // // on_nft_received call13091310 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13111312 // Ok(())1313 // }13141315 /// Set off-chain data schema.1316 /// 1317 /// # Permissions1318 /// 1319 /// * Collection Owner1320 /// * Collection Admin1321 /// 1322 /// # Arguments1323 /// 1324 /// * collection_id.1325 /// 1326 /// * schema: String representing the offchain data schema.1327 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1328 #[transactional]1329 pub fn set_variable_meta_data (1330 origin,1331 collection_id: CollectionId,1332 item_id: TokenId,1333 data: Vec<u8>1334 ) -> DispatchResult {1335 let sender = ensure_signed(origin)?;1336 1337 let target_collection = Self::get_collection(collection_id)?;1338 Self::token_exists(&target_collection, item_id)?;13391340 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13411342 // Modify permissions check1343 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1344 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1345 Error::<T>::NoPermission);13461347 match target_collection.mode1348 {1349 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1350 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1351 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1352 _ => fail!(Error::<T>::UnexpectedCollectionType)1353 };13541355 Ok(())1356 }1357 1358 /// Set schema standard1359 /// ImageURL1360 /// Unique1361 /// 1362 /// # Permissions1363 /// 1364 /// * Collection Owner1365 /// * Collection Admin1366 /// 1367 /// # Arguments1368 /// 1369 /// * collection_id.1370 /// 1371 /// * schema: SchemaVersion: enum1372 #[weight = <T as Config>::WeightInfo::set_schema_version()]1373 #[transactional]1374 pub fn set_schema_version(1375 origin,1376 collection_id: CollectionId,1377 version: SchemaVersion1378 ) -> DispatchResult {1379 let sender = ensure_signed(origin)?;1380 let mut target_collection = Self::get_collection(collection_id)?;1381 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1382 target_collection.schema_version = version;1383 Self::save_collection(target_collection);13841385 Ok(())1386 }13871388 /// Set off-chain data schema.1389 /// 1390 /// # Permissions1391 /// 1392 /// * Collection Owner1393 /// * Collection Admin1394 /// 1395 /// # Arguments1396 /// 1397 /// * collection_id.1398 /// 1399 /// * schema: String representing the offchain data schema.1400 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1401 #[transactional]1402 pub fn set_offchain_schema(1403 origin,1404 collection_id: CollectionId,1405 schema: Vec<u8>1406 ) -> DispatchResult {1407 let sender = ensure_signed(origin)?;1408 let mut target_collection = Self::get_collection(collection_id)?;1409 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14101411 // check schema limit1412 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14131414 target_collection.offchain_schema = schema;1415 Self::save_collection(target_collection);14161417 Ok(())1418 }14191420 /// Set const on-chain data schema.1421 /// 1422 /// # Permissions1423 /// 1424 /// * Collection Owner1425 /// * Collection Admin1426 /// 1427 /// # Arguments1428 /// 1429 /// * collection_id.1430 /// 1431 /// * schema: String representing the const on-chain data schema.1432 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1433 #[transactional]1434 pub fn set_const_on_chain_schema (1435 origin,1436 collection_id: CollectionId,1437 schema: Vec<u8>1438 ) -> DispatchResult {1439 let sender = ensure_signed(origin)?;1440 let mut target_collection = Self::get_collection(collection_id)?;1441 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14421443 // check schema limit1444 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14451446 target_collection.const_on_chain_schema = schema;1447 Self::save_collection(target_collection);14481449 Ok(())1450 }14511452 /// Set variable on-chain data schema.1453 /// 1454 /// # Permissions1455 /// 1456 /// * Collection Owner1457 /// * Collection Admin1458 /// 1459 /// # Arguments1460 /// 1461 /// * collection_id.1462 /// 1463 /// * schema: String representing the variable on-chain data schema.1464 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1465 #[transactional]1466 pub fn set_variable_on_chain_schema (1467 origin,1468 collection_id: CollectionId,1469 schema: Vec<u8>1470 ) -> DispatchResult {1471 let sender = ensure_signed(origin)?;1472 let mut target_collection = Self::get_collection(collection_id)?;1473 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14741475 // check schema limit1476 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14771478 target_collection.variable_on_chain_schema = schema;1479 Self::save_collection(target_collection);14801481 Ok(())1482 }14831484 // Sudo permissions function1485 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1486 #[transactional]1487 pub fn set_chain_limits(1488 origin,1489 limits: ChainLimits1490 ) -> DispatchResult {14911492 #[cfg(not(feature = "runtime-benchmarks"))]1493 ensure_root(origin)?;14941495 <ChainLimit>::put(limits);1496 Ok(())1497 }14981499 /// Enable smart contract self-sponsoring.1500 /// 1501 /// # Permissions1502 /// 1503 /// * Contract Owner1504 /// 1505 /// # Arguments1506 /// 1507 /// * contract address1508 /// * enable flag1509 /// 1510 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1511 #[transactional]1512 pub fn enable_contract_sponsoring(1513 origin,1514 contract_address: T::AccountId,1515 enable: bool1516 ) -> DispatchResult {15171518 let sender = ensure_signed(origin)?;15191520 #[cfg(feature = "runtime-benchmarks")]1521 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15221523 Self::ensure_contract_owned(sender, &contract_address)?;15241525 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1526 Ok(())1527 }15281529 /// Set the rate limit for contract sponsoring to specified number of blocks.1530 /// 1531 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1532 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1533 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1534 /// from contract endowment if there are at least B blocks between such transactions. 1535 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1536 /// 1537 /// # Permissions1538 /// 1539 /// * Contract Owner1540 /// 1541 /// # Arguments1542 /// 1543 /// -`contract_address`: Address of the contract to sponsor1544 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1545 /// 1546 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1547 #[transactional]1548 pub fn set_contract_sponsoring_rate_limit(1549 origin,1550 contract_address: T::AccountId,1551 rate_limit: T::BlockNumber1552 ) -> DispatchResult {1553 let sender = ensure_signed(origin)?;15541555 #[cfg(feature = "runtime-benchmarks")]1556 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15571558 Self::ensure_contract_owned(sender, &contract_address)?;1559 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1560 Ok(())1561 }15621563 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1564 /// 1565 /// # Permissions1566 /// 1567 /// * Address that deployed smart contract.1568 /// 1569 /// # Arguments1570 /// 1571 /// -`contract_address`: Address of the contract.1572 /// 1573 /// - `enable`: . 1574 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1575 #[transactional]1576 pub fn toggle_contract_white_list(1577 origin,1578 contract_address: T::AccountId,1579 enable: bool1580 ) -> DispatchResult {1581 let sender = ensure_signed(origin)?;15821583 #[cfg(feature = "runtime-benchmarks")]1584 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15851586 Self::ensure_contract_owned(sender, &contract_address)?;1587 if enable {1588 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1589 } else {1590 <ContractWhiteListEnabled<T>>::remove(contract_address);1591 }1592 Ok(())1593 }1594 1595 /// Add an address to smart contract white list.1596 /// 1597 /// # Permissions1598 /// 1599 /// * Address that deployed smart contract.1600 /// 1601 /// # Arguments1602 /// 1603 /// -`contract_address`: Address of the contract.1604 ///1605 /// -`account_address`: Address to add.1606 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1607 #[transactional]1608 pub fn add_to_contract_white_list(1609 origin,1610 contract_address: T::AccountId,1611 account_address: T::AccountId1612 ) -> DispatchResult {1613 let sender = ensure_signed(origin)?;16141615 #[cfg(feature = "runtime-benchmarks")]1616 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1617 1618 Self::ensure_contract_owned(sender, &contract_address)?; 1619 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1620 Ok(())1621 }16221623 /// Remove an address from smart contract white list.1624 /// 1625 /// # Permissions1626 /// 1627 /// * Address that deployed smart contract.1628 /// 1629 /// # Arguments1630 /// 1631 /// -`contract_address`: Address of the contract.1632 ///1633 /// -`account_address`: Address to remove.1634 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1635 #[transactional]1636 pub fn remove_from_contract_white_list(1637 origin,1638 contract_address: T::AccountId,1639 account_address: T::AccountId1640 ) -> DispatchResult {1641 let sender = ensure_signed(origin)?;16421643 #[cfg(feature = "runtime-benchmarks")]1644 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16451646 Self::ensure_contract_owned(sender, &contract_address)?;1647 <ContractWhiteList<T>>::remove(contract_address, account_address);1648 Ok(())1649 }16501651 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1652 #[transactional]1653 pub fn set_collection_limits(1654 origin,1655 collection_id: u32,1656 new_limits: CollectionLimits<T::BlockNumber>,1657 ) -> DispatchResult {1658 let sender = ensure_signed(origin)?;1659 let mut target_collection = Self::get_collection(collection_id)?;1660 Self::check_owner_permissions(&target_collection, sender.clone())?;1661 let old_limits = &target_collection.limits;1662 let chain_limits = ChainLimit::get();16631664 // collection bounds1665 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1666 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1667 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1668 Error::<T>::CollectionLimitBoundsExceeded);16691670 // token_limit check prev1671 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1672 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16731674 ensure!(1675 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1676 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1677 Error::<T>::OwnerPermissionsCantBeReverted,1678 );16791680 target_collection.limits = new_limits;1681 Self::save_collection(target_collection);16821683 Ok(())1684 } 1685 }1686}16871688impl<T: Config> Module<T> {1689 pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1690 let target_collection = Self::get_collection(collection_id)?;16911692 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1693 Self::validate_create_item_args(&target_collection, &data)?;1694 Self::create_item_no_validation(&target_collection, owner, data)?;16951696 Ok(())1697 }16981699 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1700 // Limits check1701 Self::is_correct_transfer(target_collection, &recipient)?;17021703 // Transfer permissions check1704 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1705 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1706 Error::<T>::NoPermission);17071708 if target_collection.access == AccessMode::WhiteList {1709 Self::check_white_list(target_collection, &sender)?;1710 Self::check_white_list(target_collection, &recipient)?;1711 }17121713 match target_collection.mode1714 {1715 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1716 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1717 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1718 _ => ()1719 };17201721 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17221723 Ok(())1724 }17251726 pub fn approve_internal(1727 sender: T::AccountId,1728 spender: T::AccountId,1729 collection: &CollectionHandle<T>,1730 item_id: TokenId,1731 amount: u128,1732 ) -> DispatchResult {1733 Self::token_exists(&collection, item_id)?;17341735 // Transfer permissions check1736 let bypasses_limits = collection.limits.owner_can_transfer &&1737 Self::is_owner_or_admin_permissions(1738 &collection,1739 sender.clone(),1740 );17411742 let allowance_limit = if bypasses_limits {1743 None1744 } else if let Some(amount) = Self::owned_amount(1745 sender.clone(),1746 &collection,1747 item_id,1748 ) {1749 Some(amount)1750 } else {1751 fail!(Error::<T>::NoPermission);1752 };17531754 if collection.access == AccessMode::WhiteList {1755 Self::check_white_list(&collection, &sender)?;1756 Self::check_white_list(&collection, &spender)?;1757 }17581759 let allowance: u128 = amount1760 .checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1761 .ok_or(Error::<T>::NumOverflow)?;1762 if let Some(limit) = allowance_limit {1763 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1764 }1765 <Allowances<T>>::insert(collection.id, (item_id, &sender, &spender), allowance);17661767 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1768 Ok(())1769 }17701771 pub fn transfer_from_internal(1772 sender: T::AccountId,1773 from: T::AccountId,1774 recipient: T::AccountId,1775 collection: &CollectionHandle<T>,1776 item_id: TokenId,1777 amount: u128,1778 ) -> DispatchResult {1779 // Check approval1780 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));17811782 // Limits check1783 Self::is_correct_transfer(&collection, &recipient)?;17841785 // Transfer permissions check1786 ensure!(1787 approval >= amount || 1788 (1789 collection.limits.owner_can_transfer &&1790 Self::is_owner_or_admin_permissions(&collection, sender.clone())1791 ),1792 Error::<T>::NoPermission1793 );17941795 if collection.access == AccessMode::WhiteList {1796 Self::check_white_list(&collection, &sender)?;1797 Self::check_white_list(&collection, &recipient)?;1798 }17991800 // Reduce approval by transferred amount or remove if remaining approval drops to 01801 let allowance = approval.saturating_sub(amount);1802 if allowance > 0 {1803 <Allowances<T>>::insert(collection.id, (item_id, &from, &sender), allowance);1804 } else {1805 <Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1806 }18071808 match collection.mode {1809 CollectionMode::NFT => {1810 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1811 }1812 CollectionMode::Fungible(_) => {1813 Self::transfer_fungible(&collection, amount, &from, &recipient)?1814 }1815 CollectionMode::ReFungible => {1816 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1817 }1818 _ => ()1819 };18201821 Ok(())1822 }18231824 pub fn create_multiple_items_internal(1825 sender: T::AccountId,1826 collection: &CollectionHandle<T>,1827 owner: T::AccountId,1828 items_data: Vec<CreateItemData>,1829 ) -> DispatchResult {1830 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18311832 for data in &items_data {1833 Self::validate_create_item_args(&collection, data)?;1834 }1835 for data in &items_data {1836 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1837 }18381839 Ok(())1840 }18411842 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1843 let collection_id = collection.id;18441845 // check token limit and account token limit1846 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1847 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1848 1849 Ok(())1850 }18511852 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1853 let collection_id = collection.id;18541855 // check token limit and account token limit1856 let total_items: u32 = ItemListIndex::get(collection_id)1857 .checked_add(amount)1858 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1859 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1860 .checked_add(amount)1861 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1862 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1863 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18641865 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1866 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1867 Self::check_white_list(collection, owner)?;1868 Self::check_white_list(collection, sender)?;1869 }18701871 Ok(())1872 }18731874 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1875 match target_collection.mode1876 {1877 CollectionMode::NFT => {1878 if let CreateItemData::NFT(data) = data {1879 // check sizes1880 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1881 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1882 } else {1883 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1884 }1885 },1886 CollectionMode::Fungible(_) => {1887 if let CreateItemData::Fungible(_) = data {1888 } else {1889 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1890 }1891 },1892 CollectionMode::ReFungible => {1893 if let CreateItemData::ReFungible(data) = data {18941895 // check sizes1896 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1897 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18981899 // Check refungibility limits1900 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1901 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1902 } else {1903 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1904 }1905 },1906 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1907 };19081909 Ok(())1910 }19111912 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1913 match data1914 {1915 CreateItemData::NFT(data) => {1916 let item = NftItemType {1917 owner: owner.clone(),1918 const_data: data.const_data,1919 variable_data: data.variable_data1920 };19211922 Self::add_nft_item(collection, item)?;1923 },1924 CreateItemData::Fungible(data) => {1925 Self::add_fungible_item(collection, &owner, data.value)?;1926 },1927 CreateItemData::ReFungible(data) => {1928 let mut owner_list = Vec::new();1929 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19301931 let item = ReFungibleItemType {1932 owner: owner_list,1933 const_data: data.const_data,1934 variable_data: data.variable_data1935 };19361937 Self::add_refungible_item(collection, item)?;1938 }1939 };19401941 Ok(())1942 }19431944 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1945 let collection_id = collection.id;19461947 // Does new owner already have an account?1948 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19491950 // Mint 1951 let item = FungibleItemType {1952 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1953 };1954 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19551956 // Update balance1957 let new_balance = <Balance<T>>::get(collection_id, owner)1958 .checked_add(value)1959 .ok_or(Error::<T>::NumOverflow)?;1960 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19611962 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1963 Ok(())1964 }19651966 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1967 let collection_id = collection.id;19681969 let current_index = <ItemListIndex>::get(collection_id)1970 .checked_add(1)1971 .ok_or(Error::<T>::NumOverflow)?;1972 let itemcopy = item.clone();19731974 ensure!(1975 item.owner.len() == 1,1976 Error::<T>::BadCreateRefungibleCall,1977 );1978 let item_owner = item.owner.first().expect("only one owner is defined");19791980 let value = item_owner.fraction;1981 let owner = item_owner.owner.clone();19821983 Self::add_token_index(collection_id, current_index, &owner)?;19841985 <ItemListIndex>::insert(collection_id, current_index);1986 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19871988 // Update balance1989 let new_balance = <Balance<T>>::get(collection_id, &owner)1990 .checked_add(value)1991 .ok_or(Error::<T>::NumOverflow)?;1992 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19931994 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1995 Ok(())1996 }19971998 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1999 let collection_id = collection.id;20002001 let current_index = <ItemListIndex>::get(collection_id)2002 .checked_add(1)2003 .ok_or(Error::<T>::NumOverflow)?;20042005 let item_owner = item.owner.clone();2006 Self::add_token_index(collection_id, current_index, &item.owner)?;20072008 <ItemListIndex>::insert(collection_id, current_index);2009 <NftItemList<T>>::insert(collection_id, current_index, item);20102011 // Update balance2012 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())2013 .checked_add(1)2014 .ok_or(Error::<T>::NumOverflow)?;2015 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);20162017 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2018 Ok(())2019 }20202021 fn burn_refungible_item(2022 collection: &CollectionHandle<T>,2023 item_id: TokenId,2024 owner: &T::AccountId,2025 ) -> DispatchResult {2026 let collection_id = collection.id;20272028 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2029 .ok_or(Error::<T>::TokenNotFound)?;2030 let rft_balance = token2031 .owner2032 .iter()2033 .find(|&i| i.owner == *owner)2034 .ok_or(Error::<T>::TokenNotFound)?;2035 Self::remove_token_index(collection_id, item_id, owner)?;20362037 // update balance2038 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2039 .checked_sub(rft_balance.fraction)2040 .ok_or(Error::<T>::NumOverflow)?;2041 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20422043 // Re-create owners list with sender removed2044 let index = token2045 .owner2046 .iter()2047 .position(|i| i.owner == *owner)2048 .expect("owned item is exists");2049 token.owner.remove(index);2050 let owner_count = token.owner.len();20512052 // Burn the token completely if this was the last (only) owner2053 if owner_count == 0 {2054 <ReFungibleItemList<T>>::remove(collection_id, item_id);2055 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2056 }2057 else {2058 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2059 }20602061 Ok(())2062 }20632064 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2065 let collection_id = collection.id;20662067 let item = <NftItemList<T>>::get(collection_id, item_id)2068 .ok_or(Error::<T>::TokenNotFound)?;2069 Self::remove_token_index(collection_id, item_id, &item.owner)?;20702071 // update balance2072 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2073 .checked_sub(1)2074 .ok_or(Error::<T>::NumOverflow)?;2075 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2076 <NftItemList<T>>::remove(collection_id, item_id);2077 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20782079 Ok(())2080 }20812082 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2083 let collection_id = collection.id;20842085 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2086 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20872088 // update balance2089 let new_balance = <Balance<T>>::get(collection_id, owner)2090 .checked_sub(value)2091 .ok_or(Error::<T>::NumOverflow)?;2092 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20932094 if balance.value - value > 0 {2095 balance.value -= value;2096 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2097 }2098 else {2099 <FungibleItemList<T>>::remove(collection_id, owner);2100 }21012102 Ok(())2103 }21042105 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2106 Ok(<CollectionById<T>>::get(collection_id)2107 .map(|collection| CollectionHandle {2108 id: collection_id,2109 collection2110 })2111 .ok_or(Error::<T>::CollectionNotFound)?)2112 }21132114 fn save_collection(collection: CollectionHandle<T>) {2115 <CollectionById<T>>::insert(collection.id, collection.collection);2116 }21172118 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2119 ensure!(2120 subject == target_collection.owner,2121 Error::<T>::NoPermission2122 );21232124 Ok(())2125 }21262127 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2128 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2129 }21302131 fn check_owner_or_admin_permissions(2132 collection: &CollectionHandle<T>,2133 subject: T::AccountId,2134 ) -> DispatchResult {2135 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21362137 Ok(())2138 }21392140 fn owned_amount(2141 subject: T::AccountId,2142 target_collection: &CollectionHandle<T>,2143 item_id: TokenId,2144 ) -> Option<u128> {2145 let collection_id = target_collection.id;21462147 match target_collection.mode {2148 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2149 .then(|| 1),2150 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2151 .value),2152 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2153 .owner2154 .iter()2155 .find(|i| i.owner == subject)2156 .map(|i| i.fraction),2157 CollectionMode::Invalid => None,2158 }2159 }21602161 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2162 match target_collection.mode {2163 CollectionMode::Fungible(_) => true,2164 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2165 }2166 }21672168 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2169 let collection_id = collection.id;21702171 let mes = Error::<T>::AddresNotInWhiteList;2172 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21732174 Ok(())2175 }21762177 /// Check if token exists. In case of Fungible, check if there is an entry for 2178 /// the owner in fungible balances double map2179 fn token_exists(2180 target_collection: &CollectionHandle<T>,2181 item_id: TokenId,2182 ) -> DispatchResult {2183 let collection_id = target_collection.id;2184 let exists = match target_collection.mode2185 {2186 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2187 CollectionMode::Fungible(_) => true,2188 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2189 _ => false2190 };21912192 ensure!(exists == true, Error::<T>::TokenNotFound);2193 Ok(())2194 }21952196 fn transfer_fungible(2197 collection: &CollectionHandle<T>,2198 value: u128,2199 owner: &T::AccountId,2200 recipient: &T::AccountId,2201 ) -> DispatchResult {2202 let collection_id = collection.id;22032204 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2205 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22062207 // Send balance to recipient (updates balanceOf of recipient)2208 Self::add_fungible_item(collection, recipient, value)?;22092210 // update balanceOf of sender2211 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22122213 // Reduce or remove sender2214 if balance.value == value {2215 <FungibleItemList<T>>::remove(collection_id, owner);2216 }2217 else {2218 balance.value -= value;2219 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2220 }22212222 Ok(())2223 }22242225 fn transfer_refungible(2226 collection: &CollectionHandle<T>,2227 item_id: TokenId,2228 value: u128,2229 owner: T::AccountId,2230 new_owner: T::AccountId,2231 ) -> DispatchResult {2232 let collection_id = collection.id;2233 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2234 .ok_or(Error::<T>::TokenNotFound)?;22352236 let item = full_item2237 .owner2238 .iter()2239 .filter(|i| i.owner == owner)2240 .next()2241 .ok_or(Error::<T>::TokenNotFound)?;2242 let amount = item.fraction;22432244 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22452246 // update balance2247 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2248 .checked_sub(value)2249 .ok_or(Error::<T>::NumOverflow)?;2250 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22512252 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2253 .checked_add(value)2254 .ok_or(Error::<T>::NumOverflow)?;2255 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22562257 let old_owner = item.owner.clone();2258 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22592260 // transfer2261 if amount == value && !new_owner_has_account {2262 // change owner2263 // new owner do not have account2264 let mut new_full_item = full_item.clone();2265 new_full_item2266 .owner2267 .iter_mut()2268 .find(|i| i.owner == owner)2269 .expect("old owner does present in refungible")2270 .owner = new_owner.clone();2271 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22722273 // update index collection2274 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2275 } else {2276 let mut new_full_item = full_item.clone();2277 new_full_item2278 .owner2279 .iter_mut()2280 .find(|i| i.owner == owner)2281 .expect("old owner does present in refungible")2282 .fraction -= value;22832284 // separate amount2285 if new_owner_has_account {2286 // new owner has account2287 new_full_item2288 .owner2289 .iter_mut()2290 .find(|i| i.owner == new_owner)2291 .expect("new owner has account")2292 .fraction += value;2293 } else {2294 // new owner do not have account2295 new_full_item.owner.push(Ownership {2296 owner: new_owner.clone(),2297 fraction: value,2298 });2299 Self::add_token_index(collection_id, item_id, &new_owner)?;2300 }23012302 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2303 }23042305 Ok(())2306 }23072308 fn transfer_nft(2309 collection: &CollectionHandle<T>,2310 item_id: TokenId,2311 sender: T::AccountId,2312 new_owner: T::AccountId,2313 ) -> DispatchResult {2314 let collection_id = collection.id;2315 let mut item = <NftItemList<T>>::get(collection_id, item_id)2316 .ok_or(Error::<T>::TokenNotFound)?;23172318 ensure!(2319 sender == item.owner,2320 Error::<T>::MustBeTokenOwner2321 );23222323 // update balance2324 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2325 .checked_sub(1)2326 .ok_or(Error::<T>::NumOverflow)?;2327 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23282329 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2330 .checked_add(1)2331 .ok_or(Error::<T>::NumOverflow)?;2332 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23332334 // change owner2335 let old_owner = item.owner.clone();2336 item.owner = new_owner.clone();2337 <NftItemList<T>>::insert(collection_id, item_id, item);23382339 // update index collection2340 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23412342 Ok(())2343 }2344 2345 fn set_re_fungible_variable_data(2346 collection: &CollectionHandle<T>,2347 item_id: TokenId,2348 data: Vec<u8>2349 ) -> DispatchResult {2350 let collection_id = collection.id;2351 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2352 .ok_or(Error::<T>::TokenNotFound)?;23532354 item.variable_data = data;23552356 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23572358 Ok(())2359 }23602361 fn set_nft_variable_data(2362 collection: &CollectionHandle<T>,2363 item_id: TokenId,2364 data: Vec<u8>2365 ) -> DispatchResult {2366 let collection_id = collection.id;2367 let mut item = <NftItemList<T>>::get(collection_id, item_id)2368 .ok_or(Error::<T>::TokenNotFound)?;2369 2370 item.variable_data = data;23712372 <NftItemList<T>>::insert(collection_id, item_id, item);2373 2374 Ok(())2375 }23762377 fn init_collection(item: &Collection<T>) {2378 // check params2379 assert!(2380 item.decimal_points <= MAX_DECIMAL_POINTS,2381 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2382 );2383 assert!(2384 item.name.len() <= 64,2385 "Collection name can not be longer than 63 char"2386 );2387 assert!(2388 item.name.len() <= 256,2389 "Collection description can not be longer than 255 char"2390 );2391 assert!(2392 item.token_prefix.len() <= 16,2393 "Token prefix can not be longer than 15 char"2394 );23952396 // Generate next collection ID2397 let next_id = CreatedCollectionCount::get()2398 .checked_add(1)2399 .unwrap();24002401 CreatedCollectionCount::put(next_id);2402 }24032404 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2405 let current_index = <ItemListIndex>::get(collection_id)2406 .checked_add(1)2407 .unwrap();24082409 let item_owner = item.owner.clone();2410 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24112412 <ItemListIndex>::insert(collection_id, current_index);24132414 // Update balance2415 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2416 .checked_add(1)2417 .unwrap();2418 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2419 }24202421 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2422 let current_index = <ItemListIndex>::get(collection_id)2423 .checked_add(1)2424 .unwrap();24252426 Self::add_token_index(collection_id, current_index, owner).unwrap();24272428 <ItemListIndex>::insert(collection_id, current_index);24292430 // Update balance2431 let new_balance = <Balance<T>>::get(collection_id, owner)2432 .checked_add(item.value)2433 .unwrap();2434 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2435 }24362437 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2438 let current_index = <ItemListIndex>::get(collection_id)2439 .checked_add(1)2440 .unwrap();24412442 let value = item.owner.first().unwrap().fraction;2443 let owner = item.owner.first().unwrap().owner.clone();24442445 Self::add_token_index(collection_id, current_index, &owner).unwrap();24462447 <ItemListIndex>::insert(collection_id, current_index);24482449 // Update balance2450 let new_balance = <Balance<T>>::get(collection_id, &owner)2451 .checked_add(value)2452 .unwrap();2453 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2454 }24552456 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2457 // add to account limit2458 if <AccountItemCount<T>>::contains_key(owner) {24592460 // bound Owned tokens by a single address2461 let count = <AccountItemCount<T>>::get(owner);2462 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24632464 <AccountItemCount<T>>::insert(owner.clone(), count2465 .checked_add(1)2466 .ok_or(Error::<T>::NumOverflow)?);2467 }2468 else {2469 <AccountItemCount<T>>::insert(owner.clone(), 1);2470 }24712472 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2473 if list_exists {2474 let mut list = <AddressTokens<T>>::get(collection_id, owner);2475 let item_contains = list.contains(&item_index.clone());24762477 if !item_contains {2478 list.push(item_index.clone());2479 }24802481 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2482 } else {2483 let mut itm = Vec::new();2484 itm.push(item_index.clone());2485 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2486 }24872488 Ok(())2489 }24902491 fn remove_token_index(2492 collection_id: CollectionId,2493 item_index: TokenId,2494 owner: &T::AccountId,2495 ) -> DispatchResult {24962497 // update counter2498 <AccountItemCount<T>>::insert(owner.clone(), 2499 <AccountItemCount<T>>::get(owner)2500 .checked_sub(1)2501 .ok_or(Error::<T>::NumOverflow)?);250225032504 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2505 if list_exists {2506 let mut list = <AddressTokens<T>>::get(collection_id, owner);2507 let item_contains = list.contains(&item_index.clone());25082509 if item_contains {2510 list.retain(|&item| item != item_index);2511 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2512 }2513 }25142515 Ok(())2516 }25172518 fn move_token_index(2519 collection_id: CollectionId,2520 item_index: TokenId,2521 old_owner: &T::AccountId,2522 new_owner: &T::AccountId,2523 ) -> DispatchResult {2524 Self::remove_token_index(collection_id, item_index, old_owner)?;2525 Self::add_token_index(collection_id, item_index, new_owner)?;25262527 Ok(())2528 }2529 2530 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2531 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25322533 Ok(())2534 }2535}25362537////////////////////////////////////////////////////////////////////////////////////////////////////2538// Economic models2539// #region25402541/// Fee multiplier.2542pub type Multiplier = FixedU128;25432544type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25452546/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2547/// in the queue.2548#[derive(Encode, Decode, Clone, Eq, PartialEq)]2549pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25502551impl<T: Config + Send + Sync> sp_std::fmt::Debug 2552 for ChargeTransactionPayment<T>2553{2554 #[cfg(feature = "std")]2555 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2556 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2557 }2558 #[cfg(not(feature = "std"))]2559 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2560 Ok(())2561 }2562}25632564impl<T: Config> ChargeTransactionPayment<T>2565where2566 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2567 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2568 T::AccountId: AsRef<[u8]>,2569 T::AccountId: UncheckedFrom<T::Hash>,2570{2571 fn traditional_fee(2572 len: usize,2573 info: &DispatchInfoOf<T::Call>,2574 tip: BalanceOf<T>,2575 ) -> BalanceOf<T>2576 where2577 T::Call: Dispatchable<Info = DispatchInfo>,2578 {2579 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2580 }25812582 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2583 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2584 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2585 let len_saturation = max_block_length as u64 / (len as u64).max(1);2586 let coefficient: BalanceOf<T> = weight_saturation2587 .min(len_saturation)2588 .saturated_into::<BalanceOf<T>>();2589 final_fee2590 .saturating_mul(coefficient)2591 .saturated_into::<TransactionPriority>()2592 }25932594 fn withdraw_fee(2595 &self,2596 who: &T::AccountId,2597 call: &T::Call,2598 info: &DispatchInfoOf<T::Call>,2599 len: usize,2600 ) -> Result<2601 (2602 BalanceOf<T>,2603 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2604 ),2605 TransactionValidityError,2606 > {2607 let tip = self.0;26082609 let fee = Self::traditional_fee(len, info, tip);26102611 // Only mess with balances if fee is not zero.2612 if fee.is_zero() {2613 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2614 .map(|i| (fee, i));2615 }26162617 // Determine who is paying transaction fee based on ecnomic model2618 // Parse call to extract collection ID and access collection sponsor2619 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2620 Some(Call::create_item(collection_id, _owner, _properties)) => {2621 let collection = <CollectionById<T>>::get(collection_id)?;26222623 // sponsor timeout2624 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26252626 let limit = collection.limits.sponsor_transfer_timeout;2627 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2628 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2629 let limit_time = last_tx_block + limit.into();2630 if block_number <= limit_time {2631 return None;2632 }2633 }2634 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26352636 // check free create limit2637 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2638 collection.sponsorship.sponsor()2639 .cloned()2640 } else {2641 None2642 }2643 }2644 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2645 let collection = <CollectionById<T>>::get(collection_id)?;2646 2647 let mut sponsor_transfer = false;2648 if collection.sponsorship.confirmed() {26492650 let collection_limits = collection.limits;2651 let collection_mode = collection.mode;2652 2653 // sponsor timeout2654 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2655 sponsor_transfer = match collection_mode {2656 CollectionMode::NFT => {2657 2658 // get correct limit2659 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2660 collection_limits.sponsor_transfer_timeout2661 } else {2662 ChainLimit::get().nft_sponsor_transfer_timeout2663 };2664 2665 let mut sponsored = true;2666 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2667 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2668 let limit_time = last_tx_block + limit.into();2669 if block_number <= limit_time {2670 sponsored = false;2671 }2672 }2673 if sponsored {2674 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2675 }26762677 sponsored2678 }2679 CollectionMode::Fungible(_) => {2680 2681 // get correct limit2682 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2683 collection_limits.sponsor_transfer_timeout2684 } else {2685 ChainLimit::get().fungible_sponsor_transfer_timeout2686 };2687 2688 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2689 let mut sponsored = true;2690 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2691 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2692 let limit_time = last_tx_block + limit.into();2693 if block_number <= limit_time {2694 sponsored = false;2695 }2696 }2697 if sponsored {2698 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2699 }27002701 sponsored2702 }2703 CollectionMode::ReFungible => {2704 2705 // get correct limit2706 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2707 collection_limits.sponsor_transfer_timeout2708 } else {2709 ChainLimit::get().refungible_sponsor_transfer_timeout2710 };2711 2712 let mut sponsored = true;2713 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2714 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2715 let limit_time = last_tx_block + limit.into();2716 if block_number <= limit_time {2717 sponsored = false;2718 }2719 }2720 if sponsored {2721 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2722 }27232724 sponsored2725 }2726 _ => {2727 false2728 },2729 };2730 }27312732 if !sponsor_transfer {2733 None2734 } else {2735 collection.sponsorship.sponsor()2736 .cloned()2737 }2738 }27392740 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2741 let mut sponsor_metadata_changes = false;27422743 let collection = <CollectionById<T>>::get(collection_id)?;27442745 if2746 collection.sponsorship.confirmed() &&2747 // Can't sponsor fungible collection, this tx will be rejected2748 // as invalid2749 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2750 data.len() <= collection.limits.sponsored_data_size as usize2751 {2752 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2753 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27542755 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2756 .map(|last_block| block_number - last_block > rate_limit)2757 .unwrap_or(true) 2758 {2759 sponsor_metadata_changes = true;2760 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2761 }2762 }2763 }27642765 if !sponsor_metadata_changes {2766 None2767 } else {2768 collection.sponsorship.sponsor().cloned()2769 }2770 }27712772 _ => None,2773 })();27742775 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2776 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27772778 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27792780 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2781 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2782 2783 if !owned_contract && white_list_enabled {2784 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2785 return Err(InvalidTransaction::Call.into());2786 }2787 }2788 },2789 _ => {},2790 }27912792 // Sponsor smart contracts2793 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27942795 // On instantiation: set the contract owner2796 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27972798 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2799 &who,2800 code_hash,2801 salt,2802 );2803 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28042805 None2806 },28072808 // On instantiation with code: set the contract owner2809 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28102811 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2812 &who,2813 &T::Hashing::hash(&_code),2814 _salt,2815 );28162817 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28182819 None2820 }28212822 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2823 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28242825 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28262827 let mut sponsor_transfer = false;2828 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2829 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2830 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2831 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2832 let limit_time = last_tx_block + rate_limit;28332834 if block_number >= limit_time {2835 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2836 sponsor_transfer = true;2837 }2838 } else {2839 sponsor_transfer = false;2840 }2841 2842 if sponsor_transfer {2843 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2844 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2845 return Some(called_contract);2846 }2847 }2848 }28492850 None2851 },28522853 _ => None,2854 });28552856 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28572858 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2859 .map(|i| (fee, i))2860 }2861}286228632864impl<T: Config + Send + Sync> SignedExtension2865 for ChargeTransactionPayment<T>2866where2867 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2868 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2869 T::AccountId: AsRef<[u8]>,2870 T::AccountId: UncheckedFrom<T::Hash>,2871{2872 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2873 type AccountId = T::AccountId;2874 type Call = T::Call;2875 type AdditionalSigned = ();2876 type Pre = (2877 // tip2878 BalanceOf<T>,2879 // who pays fee2880 Self::AccountId,2881 // imbalance resulting from withdrawing the fee2882 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2883 );2884 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2885 Ok(())2886 }28872888 fn validate(2889 &self,2890 who: &Self::AccountId,2891 call: &Self::Call,2892 info: &DispatchInfoOf<Self::Call>,2893 len: usize,2894 ) -> TransactionValidity {2895 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2896 Ok(ValidTransaction {2897 priority: Self::get_priority(len, info, fee),2898 ..Default::default()2899 })2900 }29012902 fn pre_dispatch(2903 self,2904 who: &Self::AccountId,2905 call: &Self::Call,2906 info: &DispatchInfoOf<Self::Call>,2907 len: usize,2908 ) -> Result<Self::Pre, TransactionValidityError> {2909 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2910 Ok((self.0, who.clone(), imbalance))2911 }29122913 fn post_dispatch(2914 pre: Self::Pre,2915 info: &DispatchInfoOf<Self::Call>,2916 post_info: &PostDispatchInfoOf<Self::Call>,2917 len: usize,2918 _result: &DispatchResult,2919 ) -> Result<(), TransactionValidityError> {2920 let (tip, who, imbalance) = pre;2921 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2922 len as u32,2923 info,2924 post_info,2925 tip,2926 );2927 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2928 Ok(())2929 }2930}29312932// #endregionruntime/src/chain_extension.rsdiffbeforeafterboth--- a/runtime/src/chain_extension.rs
+++ b/runtime/src/chain_extension.rs
@@ -43,6 +43,23 @@
pub data: Vec<CreateItemData>,
}
+#[derive(Debug, PartialEq, Encode, Decode)]
+pub struct NFTExtApprove<E: Ext> {
+ pub spender: <E::T as SysConfig>::AccountId,
+ pub collection_id: u32,
+ pub item_id: u32,
+ pub amount: u128,
+}
+
+#[derive(Debug, PartialEq, Encode, Decode)]
+pub struct NFTExtTransferFrom<E: Ext> {
+ pub owner: <E::T as SysConfig>::AccountId,
+ pub recipient: <E::T as SysConfig>::AccountId,
+ pub collection_id: u32,
+ pub item_id: u32,
+ pub amount: u128,
+}
+
/// The chain Extension of NFT pallet
pub struct NFTExtension;
@@ -103,6 +120,39 @@
_ => Err(DispatchError::Other("CreateMultipleItems error"))
}
},
+ 3 => {
+ // Approve
+ let mut env = env.buf_in_buf_out();
+ let input: NFTExtApprove<E> = env.read_as()?;
+
+ let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
+
+ pallet_nft::Module::<C>::approve_internal(
+ env.ext().address().clone(),
+ input.spender,
+ &collection,
+ input.item_id,
+ input.amount,
+ )?;
+ Ok(RetVal::Converging(func_id))
+ },
+ 4 => {
+ // Transfer from
+ let mut env = env.buf_in_buf_out();
+ let input: NFTExtTransferFrom<E> = env.read_as()?;
+
+ let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
+
+ pallet_nft::Module::<C>::transfer_from_internal(
+ env.ext().address().clone(),
+ input.owner,
+ input.recipient,
+ &collection,
+ input.item_id,
+ input.amount
+ )?;
+ Ok(RetVal::Converging(func_id))
+ },
_ => {
panic!("Passed unknown func_id to test chain extension: {}", func_id);
}