difftreelog
feat support burning fro evm
in: master
1 file changed
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465// Structs66// #region6768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 // decimal points78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 /// The fees are applied to the transaction sender134 Disabled,135 Unconfirmed(AccountId),136 /// Transactions are sponsored by specified account137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, // 64 include null escape char174 pub description: Vec<u16>, // 256 include null escape char175 pub token_prefix: Vec<u8>, // 16 include null escape char176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::AccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 181 pub variable_on_chain_schema: Vec<u8>, //182 pub const_on_chain_schema: Vec<u8>, //183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191 type Target = Collection<T>;192193 fn deref(&self) -> &Self::Target {194 &self.collection195 }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199 fn deref_mut(&mut self) -> &mut Self::Target {200 &mut self.collection201 }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207 pub owner: AccountId,208 pub const_data: Vec<u8>,209 pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215 pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221 pub owner: Vec<Ownership<AccountId>>,222 pub const_data: Vec<u8>,223 pub variable_data: Vec<u8>,224}225226// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]227// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]228// pub struct VestingItem<AccountId, Moment> {229// pub sender: AccountId,230// pub recipient: AccountId,231// pub collection_id: CollectionId,232// pub item_id: TokenId,233// pub amount: u64,234// pub vesting_date: Moment,235// }236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240 pub account_token_ownership_limit: u32,241 pub sponsored_data_size: u32,242 /// None - setVariableMetadata is not sponsored243 /// Some(v) - setVariableMetadata is sponsored 244 /// if there is v block between txs245 pub sponsored_data_rate_limit: Option<BlockNumber>,246 pub token_limit: u32,247248 // Timeouts for item types in passed blocks249 pub sponsor_transfer_timeout: u32,250 pub owner_can_transfer: bool,251 pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255 fn default() -> Self {256 Self { 257 account_token_ownership_limit: 10_000_000, 258 token_limit: u32::max_value(),259 sponsored_data_size: u32::MAX, 260 sponsored_data_rate_limit: None,261 sponsor_transfer_timeout: 14400,262 owner_can_transfer: true,263 owner_can_destroy: true264 }265 }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271 pub collection_numbers_limit: u32,272 pub account_token_ownership_limit: u32,273 pub collections_admins_limit: u64,274 pub custom_data_limit: u32,275276 // Timeouts for item types in passed blocks277 pub nft_sponsor_transfer_timeout: u32,278 pub fungible_sponsor_transfer_timeout: u32,279 pub refungible_sponsor_transfer_timeout: u32,280281 // Schema limits282 pub offchain_schema_limit: u32,283 pub variable_on_chain_schema_limit: u32,284 pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288 fn create_collection() -> Weight;289 fn destroy_collection() -> Weight;290 fn add_to_white_list() -> Weight;291 fn remove_from_white_list() -> Weight;292 fn set_public_access_mode() -> Weight;293 fn set_mint_permission() -> Weight;294 fn change_collection_owner() -> Weight;295 fn add_collection_admin() -> Weight;296 fn remove_collection_admin() -> Weight;297 fn set_collection_sponsor() -> Weight;298 fn confirm_sponsorship() -> Weight;299 fn remove_collection_sponsor() -> Weight;300 fn create_item(s: usize) -> Weight;301 fn burn_item() -> Weight;302 fn transfer() -> Weight;303 fn approve() -> Weight;304 fn transfer_from() -> Weight;305 fn set_offchain_schema() -> Weight;306 fn set_const_on_chain_schema() -> Weight;307 fn set_variable_on_chain_schema() -> Weight;308 fn set_variable_meta_data() -> Weight;309 fn enable_contract_sponsoring() -> Weight;310 fn set_schema_version() -> Weight;311 fn set_chain_limits() -> Weight;312 fn set_contract_sponsoring_rate_limit() -> Weight;313 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314 fn toggle_contract_white_list() -> Weight;315 fn add_to_contract_white_list() -> Weight;316 fn remove_from_contract_white_list() -> Weight;317 fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323 pub const_data: Vec<u8>,324 pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330 pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336 pub const_data: Vec<u8>,337 pub variable_data: Vec<u8>,338 pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344 NFT(CreateNftData),345 Fungible(CreateFungibleData),346 ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350 pub fn len(&self) -> usize {351 let len = match self {352 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354 _ => 0355 };356 357 return len;358 }359}360361impl From<CreateNftData> for CreateItemData {362 fn from(item: CreateNftData) -> Self {363 CreateItemData::NFT(item)364 }365}366367impl From<CreateReFungibleData> for CreateItemData {368 fn from(item: CreateReFungibleData) -> Self {369 CreateItemData::ReFungible(item)370 }371}372373impl From<CreateFungibleData> for CreateItemData {374 fn from(item: CreateFungibleData) -> Self {375 CreateItemData::Fungible(item)376 }377}378379380decl_error! {381 /// Error for non-fungible-token module.382 pub enum Error for Module<T: Config> {383 /// Total collections bound exceeded.384 TotalCollectionsLimitExceeded,385 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.386 CollectionDecimalPointLimitExceeded, 387 /// Collection name can not be longer than 63 char.388 CollectionNameLimitExceeded, 389 /// Collection description can not be longer than 255 char.390 CollectionDescriptionLimitExceeded, 391 /// Token prefix can not be longer than 15 char.392 CollectionTokenPrefixLimitExceeded,393 /// This collection does not exist.394 CollectionNotFound,395 /// Item not exists.396 TokenNotFound,397 /// Admin not found398 AdminNotFound,399 /// Arithmetic calculation overflow.400 NumOverflow, 401 /// Account already has admin role.402 AlreadyAdmin, 403 /// You do not own this collection.404 NoPermission,405 /// This address is not set as sponsor, use setCollectionSponsor first.406 ConfirmUnsetSponsorFail,407 /// Collection is not in mint mode.408 PublicMintingNotAllowed,409 /// Sender parameter and item owner must be equal.410 MustBeTokenOwner,411 /// Item balance not enough.412 TokenValueTooLow,413 /// Size of item is too large.414 NftSizeLimitExceeded,415 /// No approve found416 ApproveNotFound,417 /// Requested value more than approved.418 TokenValueNotEnough,419 /// Only approved addresses can call this method.420 ApproveRequired,421 /// Address is not in white list.422 AddresNotInWhiteList,423 /// Number of collection admins bound exceeded.424 CollectionAdminsLimitExceeded,425 /// Owned tokens by a single address bound exceeded.426 AddressOwnershipLimitExceeded,427 /// Length of items properties must be greater than 0.428 EmptyArgument,429 /// const_data exceeded data limit.430 TokenConstDataLimitExceeded,431 /// variable_data exceeded data limit.432 TokenVariableDataLimitExceeded,433 /// Not NFT item data used to mint in NFT collection.434 NotNftDataUsedToMintNftCollectionToken,435 /// Not Fungible item data used to mint in Fungible collection.436 NotFungibleDataUsedToMintFungibleCollectionToken,437 /// Not Re Fungible item data used to mint in Re Fungible collection.438 NotReFungibleDataUsedToMintReFungibleCollectionToken,439 /// Unexpected collection type.440 UnexpectedCollectionType,441 /// Can't store metadata in fungible tokens.442 CantStoreMetadataInFungibleTokens,443 /// Collection token limit exceeded444 CollectionTokenLimitExceeded,445 /// Account token limit exceeded per collection446 AccountTokenLimitExceeded,447 /// Collection limit bounds per collection exceeded448 CollectionLimitBoundsExceeded,449 /// Tried to enable permissions which are only permitted to be disabled450 OwnerPermissionsCantBeReverted,451 /// Schema data size limit bound exceeded452 SchemaDataLimitExceeded,453 /// Maximum refungibility exceeded454 WrongRefungiblePieces,455 /// createRefungible should be called with one owner456 BadCreateRefungibleCall,457 }458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463 /// Weight information for extrinsics in this pallet.464 type WeightInfo: WeightInfo;465466 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470 type CrossAccountId: CrossAccountId<Self::AccountId>;471 type Currency: Currency<Self::AccountId>;472 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473 type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479// #endregion480481// # Used definitions482//483// ## User control levels484//485// chain-controlled - key is uncontrolled by user486// i.e autoincrementing index487// can use non-cryptographic hash488// real - key is controlled by user489// but it is hard to generate enough colliding values, i.e owner of signed txs490// can use non-cryptographic hash491// controlled - key is completly controlled by users492// i.e maps with mutable keys493// should use cryptographic hash494//495// ## User control level downgrade reasons496//497// ?1 - chain-controlled -> controlled498// collections/tokens can be destroyed, resulting in massive holes499// ?2 - chain-controlled -> controlled500// same as ?1, but can be only added, resulting in easier exploitation501// ?3 - real -> controlled502// no confirmation required, so addresses can be easily generated503decl_storage! {504 trait Store for Module<T: Config> as Nft {505506 //#region Private members507 /// Id of next collection508 CreatedCollectionCount: u32;509 /// Used for migrations510 ChainVersion: u64;511 /// Id of last collection token512 /// Collection id (controlled?1)513 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514 //#endregion515516 //#region Chain limits struct517 pub ChainLimit get(fn chain_limit) config(): ChainLimits;518 //#endregion519520 //#region Bound counters521 /// Amount of collections destroyed, used for total amount tracking with522 /// CreatedCollectionCount523 DestroyedCollectionCount: u32;524 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)525 /// Account id (real)526 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527 //#endregion528529 //#region Basic collections530 /// Collection info531 /// Collection id (controlled?1)532 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533 /// List of collection admins534 /// Collection id (controlled?2)535 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536 /// Whitelisted collection users537 /// Collection id (controlled?2), user id (controlled?3)538 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539 //#endregion540541 /// How many of collection items user have542 /// Collection id (controlled?2), account id (real)543 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545 /// Amount of items which spender can transfer out of owners account (via transferFrom)546 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))547 /// TODO: Off chain worker should remove from this map when token gets removed548 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550 //#region Item collections551 /// Collection id (controlled?2), token id (controlled?1)552 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553 /// Collection id (controlled?2), owner (controlled?2)554 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555 /// Collection id (controlled?2), token id (controlled?1)556 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557 //#endregion558559 //#region Index list560 /// Collection id (controlled?2), tokens owner (controlled?2)561 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562 //#endregion563564 //#region Tokens transfer rate limit baskets565 /// (Collection id (controlled?2), who created (real))566 /// TODO: Off chain worker should remove from this map when collection gets removed567 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568 /// Collection id (controlled?2), token id (controlled?2)569 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570 /// Collection id (controlled?2), owning user (real)571 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572 /// Collection id (controlled?2), token id (controlled?2)573 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574 //#endregion575576 /// Variable metadata sponsoring577 /// Collection id (controlled?2), token id (controlled?2)578 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579 580 //#region Contract Sponsorship and Ownership581 /// Contract address (real)582 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583 /// Contract address (real)584 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585 /// (Contract address(real), caller (real))586 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587 /// Contract address (real)588 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589 /// Contract address (real)590 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591 /// Contract address (real) => Whitelisted user (controlled?3)592 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593 //#endregion594 }595 add_extra_genesis {596 build(|config: &GenesisConfig<T>| {597 // Modification of storage598 for (_num, _c) in &config.collection_id {599 <Module<T>>::init_collection(_c);600 }601602 for (_num, _c, _i) in &config.nft_item_id {603 <Module<T>>::init_nft_token(*_c, _i);604 }605606 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);608 }609610 for (_num, _c, _i) in &config.refungible_item_id {611 <Module<T>>::init_refungible_token(*_c, _i);612 }613 })614 }615}616617decl_event!(618 pub enum Event<T>619 where620 CrossAccountId = <T as Config>::CrossAccountId,621 {622 /// New collection was created623 /// 624 /// # Arguments625 /// 626 /// * collection_id: Globally unique identifier of newly created collection.627 /// 628 /// * mode: [CollectionMode] converted into u8.629 /// 630 /// * account_id: Collection owner.631 CollectionCreated(CollectionId, u8, CrossAccountId),632633 /// New item was created.634 /// 635 /// # Arguments636 /// 637 /// * collection_id: Id of the collection where item was created.638 /// 639 /// * item_id: Id of an item. Unique within the collection.640 ///641 /// * recipient: Owner of newly created item 642 ItemCreated(CollectionId, TokenId, CrossAccountId),643644 /// Collection item was burned.645 /// 646 /// # Arguments647 /// 648 /// collection_id.649 /// 650 /// item_id: Identifier of burned NFT.651 ItemDestroyed(CollectionId, TokenId),652653 /// Item was transferred654 ///655 /// * collection_id: Id of collection to which item is belong656 ///657 /// * item_id: Id of an item658 ///659 /// * sender: Original owner of item660 ///661 /// * recipient: New owner of item662 ///663 /// * amount: Always 1 for NFT664 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666 /// * collection_id667 ///668 /// * item_id669 ///670 /// * sender671 ///672 /// * spender673 ///674 /// * amount675 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676 }677);678679decl_module! {680 pub struct Module<T: Config> for enum Call 681 where 682 origin: T::Origin683 {684 fn deposit_event() = default;685 type Error = Error<T>;686687 fn on_initialize(now: T::BlockNumber) -> Weight {688 0689 }690691 /// 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.692 /// 693 /// # Permissions694 /// 695 /// * Anyone.696 /// 697 /// # Arguments698 /// 699 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.700 /// 701 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.702 /// 703 /// * token_prefix: UTF-8 string with token prefix.704 /// 705 /// * mode: [CollectionMode] collection type and type dependent data.706 // returns collection ID707 #[weight = <T as Config>::WeightInfo::create_collection()]708 #[transactional]709 pub fn create_collection(origin,710 collection_name: Vec<u16>,711 collection_description: Vec<u16>,712 token_prefix: Vec<u8>,713 mode: CollectionMode) -> DispatchResult {714715 // Anyone can create a collection716 let who = T::CrossAccountId::from_sub(ensure_signed(origin)?);717718 // Take a (non-refundable) deposit of collection creation719 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721 &T::TreasuryAccountId::get(),722 T::CollectionCreationPrice::get(),723 ));724 <T as Config>::Currency::settle(725 who.as_sub(),726 imbalance,727 WithdrawReasons::TRANSFER,728 ExistenceRequirement::KeepAlive,729 ).map_err(|_| Error::<T>::NoPermission)?;730731 let decimal_points = match mode {732 CollectionMode::Fungible(points) => points,733 _ => 0734 };735736 let chain_limit = ChainLimit::get();737738 let created_count = CreatedCollectionCount::get();739 let destroyed_count = DestroyedCollectionCount::get();740741 // bound Total number of collections742 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744 // check params745 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750 // Generate next collection ID751 let next_id = created_count752 .checked_add(1)753 .ok_or(Error::<T>::NumOverflow)?;754755 CreatedCollectionCount::put(next_id);756757 let limits = CollectionLimits {758 sponsored_data_size: chain_limit.custom_data_limit,759 ..Default::default()760 };761762 // Create new collection763 let new_collection = Collection {764 owner: who.clone(),765 name: collection_name,766 mode: mode.clone(),767 mint_mode: false,768 access: AccessMode::Normal,769 description: collection_description,770 decimal_points: decimal_points,771 token_prefix: token_prefix,772 offchain_schema: Vec::new(),773 schema_version: SchemaVersion::ImageURL,774 sponsorship: SponsorshipState::Disabled,775 variable_on_chain_schema: Vec::new(),776 const_on_chain_schema: Vec::new(),777 limits,778 };779780 // Add new collection to map781 <CollectionById<T>>::insert(next_id, new_collection);782783 // call event784 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));785786 Ok(())787 }788789 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.790 /// 791 /// # Permissions792 /// 793 /// * Collection Owner.794 /// 795 /// # Arguments796 /// 797 /// * collection_id: collection to destroy.798 #[weight = <T as Config>::WeightInfo::destroy_collection()]799 #[transactional]800 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);803 let collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&collection, sender)?;805 if !collection.limits.owner_can_destroy {806 fail!(Error::<T>::NoPermission);807 }808809 <AddressTokens<T>>::remove_prefix(collection_id);810 <Allowances<T>>::remove_prefix(collection_id);811 <Balance<T>>::remove_prefix(collection_id);812 <ItemListIndex>::remove(collection_id);813 <AdminList<T>>::remove(collection_id);814 <CollectionById<T>>::remove(collection_id);815 <WhiteList<T>>::remove_prefix(collection_id);816817 <NftItemList<T>>::remove_prefix(collection_id);818 <FungibleItemList<T>>::remove_prefix(collection_id);819 <ReFungibleItemList<T>>::remove_prefix(collection_id);820821 <NftTransferBasket<T>>::remove_prefix(collection_id);822 <FungibleTransferBasket<T>>::remove_prefix(collection_id);823 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827 DestroyedCollectionCount::put(DestroyedCollectionCount::get()828 .checked_add(1)829 .ok_or(Error::<T>::NumOverflow)?);830831 Ok(())832 }833834 /// Add an address to white list.835 /// 836 /// # Permissions837 /// 838 /// * Collection Owner839 /// * Collection Admin840 /// 841 /// # Arguments842 /// 843 /// * collection_id.844 /// 845 /// * address.846 #[weight = <T as Config>::WeightInfo::add_to_white_list()]847 #[transactional]848 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{849850 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);851 let collection = Self::get_collection(collection_id)?;852 Self::check_owner_or_admin_permissions(&collection, sender)?;853854 <WhiteList<T>>::insert(collection_id, address.as_sub(), true);855 856 Ok(())857 }858859 /// Remove an address from white list.860 /// 861 /// # Permissions862 /// 863 /// * Collection Owner864 /// * Collection Admin865 /// 866 /// # Arguments867 /// 868 /// * collection_id.869 /// 870 /// * address.871 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872 #[transactional]873 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{874875 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876 let collection = Self::get_collection(collection_id)?;877 Self::check_owner_or_admin_permissions(&collection, sender)?;878879 <WhiteList<T>>::remove(collection_id, address.as_sub());880881 Ok(())882 }883884 /// Toggle between normal and white list access for the methods with access for `Anyone`.885 /// 886 /// # Permissions887 /// 888 /// * Collection Owner.889 /// 890 /// # Arguments891 /// 892 /// * collection_id.893 /// 894 /// * mode: [AccessMode]895 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896 #[transactional]897 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898 {899 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);900901 let mut target_collection = Self::get_collection(collection_id)?;902 Self::check_owner_permissions(&target_collection, sender)?;903 target_collection.access = mode;904 Self::save_collection(target_collection);905906 Ok(())907 }908909 /// Allows Anyone to create tokens if:910 /// * White List is enabled, and911 /// * Address is added to white list, and912 /// * This method was called with True parameter913 /// 914 /// # Permissions915 /// * Collection Owner916 ///917 /// # Arguments918 /// 919 /// * collection_id.920 /// 921 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.922 #[weight = <T as Config>::WeightInfo::set_mint_permission()]923 #[transactional]924 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925 {926 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);927928 let mut target_collection = Self::get_collection(collection_id)?;929 Self::check_owner_permissions(&target_collection, sender)?;930 target_collection.mint_mode = mint_permission;931 Self::save_collection(target_collection);932933 Ok(())934 }935936 /// Change the owner of the collection.937 /// 938 /// # Permissions939 /// 940 /// * Collection Owner.941 /// 942 /// # Arguments943 /// 944 /// * collection_id.945 /// 946 /// * new_owner.947 #[weight = <T as Config>::WeightInfo::change_collection_owner()]948 #[transactional]949 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::CrossAccountId) -> DispatchResult {950951 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);952 let mut target_collection = Self::get_collection(collection_id)?;953 Self::check_owner_permissions(&target_collection, sender)?;954 target_collection.owner = new_owner;955 Self::save_collection(target_collection);956957 Ok(())958 }959960 /// Adds an admin of the Collection.961 /// 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. 962 /// 963 /// # Permissions964 /// 965 /// * Collection Owner.966 /// * Collection Admin.967 /// 968 /// # Arguments969 /// 970 /// * collection_id: ID of the Collection to add admin for.971 /// 972 /// * new_admin_id: Address of new admin to add.973 #[weight = <T as Config>::WeightInfo::add_collection_admin()]974 #[transactional]975 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {976977 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);978 let collection = Self::get_collection(collection_id)?;979 Self::check_owner_or_admin_permissions(&collection, sender)?;980 let mut admin_arr = <AdminList<T>>::get(collection_id);981982 match admin_arr.binary_search(&new_admin_id) {983 Ok(_) => {},984 Err(idx) => {985 let limits = ChainLimit::get();986 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);987 admin_arr.insert(idx, new_admin_id);988 <AdminList<T>>::insert(collection_id, admin_arr);989 }990 }991 Ok(())992 }993994 /// 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.995 ///996 /// # Permissions997 /// 998 /// * Collection Owner.999 /// * Collection Admin.1000 /// 1001 /// # Arguments1002 /// 1003 /// * collection_id: ID of the Collection to remove admin for.1004 /// 1005 /// * account_id: Address of admin to remove.1006 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1007 #[transactional]1008 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {10091010 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1011 let collection = Self::get_collection(collection_id)?;1012 Self::check_owner_or_admin_permissions(&collection, sender)?;1013 let mut admin_arr = <AdminList<T>>::get(collection_id);10141015 match admin_arr.binary_search(&account_id) {1016 Ok(idx) => {1017 admin_arr.remove(idx);1018 <AdminList<T>>::insert(collection_id, admin_arr);1019 },1020 Err(_) => {}1021 }1022 Ok(())1023 }10241025 /// # Permissions1026 /// 1027 /// * Collection Owner1028 /// 1029 /// # Arguments1030 /// 1031 /// * collection_id.1032 /// 1033 /// * new_sponsor.1034 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1035 #[transactional]1036 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1037 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1038 let mut target_collection = Self::get_collection(collection_id)?;1039 Self::check_owner_permissions(&target_collection, &sender)?;10401041 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1042 Self::save_collection(target_collection);10431044 Ok(())1045 }10461047 /// # Permissions1048 /// 1049 /// * Sponsor.1050 /// 1051 /// # Arguments1052 /// 1053 /// * collection_id.1054 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1055 #[transactional]1056 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1057 let sender = ensure_signed(origin)?;10581059 let mut target_collection = Self::get_collection(collection_id)?;1060 ensure!(1061 target_collection.sponsorship.pending_sponsor() == Some(&sender),1062 Error::<T>::ConfirmUnsetSponsorFail1063 );10641065 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1066 Self::save_collection(target_collection);10671068 Ok(())1069 }10701071 /// Switch back to pay-per-own-transaction model.1072 ///1073 /// # Permissions1074 ///1075 /// * Collection owner.1076 /// 1077 /// # Arguments1078 /// 1079 /// * collection_id.1080 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1081 #[transactional]1082 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1083 let sender = ensure_signed(origin)?;10841085 let mut target_collection = Self::get_collection(collection_id)?;1086 Self::check_owner_permissions(&target_collection, sender)?;10871088 target_collection.sponsorship = SponsorshipState::Disabled;1089 Self::save_collection(target_collection);10901091 Ok(())1092 }10931094 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1095 /// 1096 /// # Permissions1097 /// 1098 /// * Collection Owner.1099 /// * Collection Admin.1100 /// * Anyone if1101 /// * White List is enabled, and1102 /// * Address is added to white list, and1103 /// * MintPermission is enabled (see SetMintPermission method)1104 /// 1105 /// # Arguments1106 /// 1107 /// * collection_id: ID of the collection.1108 /// 1109 /// * owner: Address, initial owner of the NFT.1110 ///1111 /// * data: Token data to store on chain.1112 // #[weight =1113 // (130_000_000 as Weight)1114 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1115 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1116 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11171118 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1119 #[transactional]1120 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {11211122 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124 let target_collection = Self::get_collection(collection_id)?;11251126 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1127 Self::validate_create_item_args(&target_collection, &data)?;1128 Self::create_item_no_validation(&target_collection, owner, data)?;11291130 Ok(())1131 }11321133 /// This method creates multiple items in a collection created with CreateCollection method.1134 /// 1135 /// # Permissions1136 /// 1137 /// * Collection Owner.1138 /// * Collection Admin.1139 /// * Anyone if1140 /// * White List is enabled, and1141 /// * Address is added to white list, and1142 /// * MintPermission is enabled (see SetMintPermission method)1143 /// 1144 /// # Arguments1145 /// 1146 /// * collection_id: ID of the collection.1147 /// 1148 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1149 /// 1150 /// * owner: Address, initial owner of the NFT.1151 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1152 .map(|data| { data.len() })1153 .sum())]1154 #[transactional]1155 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11561157 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1158 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1159 let collection = Self::get_collection(collection_id)?;11601161 Self::create_multiple_items_internal(sender, &collection, owner, items_data)?;11621163 Ok(())1164 }11651166 /// Destroys a concrete instance of NFT.1167 /// 1168 /// # Permissions1169 /// 1170 /// * Collection Owner.1171 /// * Collection Admin.1172 /// * Current NFT Owner.1173 /// 1174 /// # Arguments1175 /// 1176 /// * collection_id: ID of the collection.1177 /// 1178 /// * item_id: ID of NFT to burn.1179 #[weight = <T as Config>::WeightInfo::burn_item()]1180 #[transactional]1181 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11821183 let sender = ensure_signed(origin)?;11841185 // Transfer permissions check1186 let target_collection = Self::get_collection(collection_id)?;1187 ensure!(1188 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1189 (1190 target_collection.limits.owner_can_transfer &&1191 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1192 ),1193 Error::<T>::NoPermission1194 );11951196 if target_collection.access == AccessMode::WhiteList {1197 Self::check_white_list(&target_collection, &sender)?;1198 }11991200 match target_collection.mode1201 {1202 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1203 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1204 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1205 _ => ()1206 };12071208 // call event1209 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12101211 Ok(())1212 }12131214 /// Change ownership of the token.1215 /// 1216 /// # Permissions1217 /// 1218 /// * Collection Owner1219 /// * Collection Admin1220 /// * Current NFT owner1221 ///1222 /// # Arguments1223 /// 1224 /// * recipient: Address of token recipient.1225 /// 1226 /// * collection_id.1227 /// 1228 /// * item_id: ID of the item1229 /// * Non-Fungible Mode: Required.1230 /// * Fungible Mode: Ignored.1231 /// * Re-Fungible Mode: Required.1232 /// 1233 /// * value: Amount to transfer.1234 /// * Non-Fungible Mode: Ignored1235 /// * Fungible Mode: Must specify transferred amount1236 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1237 #[weight = <T as Config>::WeightInfo::transfer()]1238 #[transactional]1239 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1240 let sender = ensure_signed(origin)?;1241 let collection = Self::get_collection(collection_id)?;12421243 Self::transfer_internal(sender, recipient, &collection, item_id, value)1244 }12451246 /// Set, change, or remove approved address to transfer the ownership of the NFT.1247 /// 1248 /// # Permissions1249 /// 1250 /// * Collection Owner1251 /// * Collection Admin1252 /// * Current NFT owner1253 /// 1254 /// # Arguments1255 /// 1256 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1257 /// 1258 /// * collection_id.1259 /// 1260 /// * item_id: ID of the item.1261 #[weight = <T as Config>::WeightInfo::approve()]1262 #[transactional]1263 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12641265 let sender = ensure_signed(origin)?;1266 let target_collection = Self::get_collection(collection_id)?;12671268 Self::token_exists(&target_collection, item_id)?;12691270 // Transfer permissions check1271 let bypasses_limits = target_collection.limits.owner_can_transfer &&1272 Self::is_owner_or_admin_permissions(1273 &target_collection,1274 sender.clone(),1275 );12761277 let allowance_limit = if bypasses_limits {1278 None1279 } else if let Some(amount) = Self::owned_amount(1280 sender.clone(),1281 &target_collection,1282 item_id,1283 ) {1284 Some(amount)1285 } else {1286 fail!(Error::<T>::NoPermission);1287 };12881289 if target_collection.access == AccessMode::WhiteList {1290 Self::check_white_list(&target_collection, &sender)?;1291 Self::check_white_list(&target_collection, &spender)?;1292 }12931294 let allowance: u128 = amount1295 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1296 .ok_or(Error::<T>::NumOverflow)?;1297 if let Some(limit) = allowance_limit {1298 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1299 }1300 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13011302 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1303 Ok(())1304 }1305 1306 /// 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.1307 /// 1308 /// # Permissions1309 /// * Collection Owner1310 /// * Collection Admin1311 /// * Current NFT owner1312 /// * Address approved by current NFT owner1313 /// 1314 /// # Arguments1315 /// 1316 /// * from: Address that owns token.1317 /// 1318 /// * recipient: Address of token recipient.1319 /// 1320 /// * collection_id.1321 /// 1322 /// * item_id: ID of the item.1323 /// 1324 /// * value: Amount to transfer.1325 #[weight = <T as Config>::WeightInfo::transfer_from()]1326 #[transactional]1327 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13281329 let sender = ensure_signed(origin)?;1330 let target_collection = Self::get_collection(collection_id)?;13311332 // Check approval1333 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13341335 // Limits check1336 Self::is_correct_transfer(&target_collection, &recipient)?;13371338 // Transfer permissions check 1339 ensure!(1340 approval >= value || 1341 (1342 target_collection.limits.owner_can_transfer &&1343 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1344 ),1345 Error::<T>::NoPermission1346 );13471348 if target_collection.access == AccessMode::WhiteList {1349 Self::check_white_list(&target_collection, &sender)?;1350 Self::check_white_list(&target_collection, &recipient)?;1351 }13521353 // Reduce approval by transferred amount or remove if remaining approval drops to 01354 if approval.saturating_sub(value) > 0 {1355 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1356 }1357 else {1358 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1359 }13601361 match target_collection.mode1362 {1363 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1364 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1365 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1366 _ => ()1367 };13681369 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1370 Ok(())1371 }13721373 // #[weight = 0]1374 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13751376 // // let no_perm_mes = "You do not have permissions to modify this collection";1377 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1378 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1379 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13801381 // // // on_nft_received call13821383 // // Self::transfer(origin, collection_id, item_id, new_owner)?;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_variable_meta_data()]1401 #[transactional]1402 pub fn set_variable_meta_data (1403 origin,1404 collection_id: CollectionId,1405 item_id: TokenId,1406 data: Vec<u8>1407 ) -> DispatchResult {1408 let sender = ensure_signed(origin)?;1409 1410 let target_collection = Self::get_collection(collection_id)?;1411 Self::token_exists(&target_collection, item_id)?;14121413 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14141415 // Modify permissions check1416 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1417 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1418 Error::<T>::NoPermission);14191420 match target_collection.mode1421 {1422 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1423 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1424 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1425 _ => fail!(Error::<T>::UnexpectedCollectionType)1426 };14271428 Ok(())1429 }1430 1431 /// Set schema standard1432 /// ImageURL1433 /// Unique1434 /// 1435 /// # Permissions1436 /// 1437 /// * Collection Owner1438 /// * Collection Admin1439 /// 1440 /// # Arguments1441 /// 1442 /// * collection_id.1443 /// 1444 /// * schema: SchemaVersion: enum1445 #[weight = <T as Config>::WeightInfo::set_schema_version()]1446 #[transactional]1447 pub fn set_schema_version(1448 origin,1449 collection_id: CollectionId,1450 version: SchemaVersion1451 ) -> DispatchResult {1452 let sender = ensure_signed(origin)?;1453 let mut target_collection = Self::get_collection(collection_id)?;1454 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1455 target_collection.schema_version = version;1456 Self::save_collection(target_collection);14571458 Ok(())1459 }14601461 /// Set off-chain data schema.1462 /// 1463 /// # Permissions1464 /// 1465 /// * Collection Owner1466 /// * Collection Admin1467 /// 1468 /// # Arguments1469 /// 1470 /// * collection_id.1471 /// 1472 /// * schema: String representing the offchain data schema.1473 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1474 #[transactional]1475 pub fn set_offchain_schema(1476 origin,1477 collection_id: CollectionId,1478 schema: Vec<u8>1479 ) -> DispatchResult {1480 let sender = ensure_signed(origin)?;1481 let mut target_collection = Self::get_collection(collection_id)?;1482 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14831484 // check schema limit1485 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14861487 target_collection.offchain_schema = schema;1488 Self::save_collection(target_collection);14891490 Ok(())1491 }14921493 /// Set const on-chain data schema.1494 /// 1495 /// # Permissions1496 /// 1497 /// * Collection Owner1498 /// * Collection Admin1499 /// 1500 /// # Arguments1501 /// 1502 /// * collection_id.1503 /// 1504 /// * schema: String representing the const on-chain data schema.1505 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1506 #[transactional]1507 pub fn set_const_on_chain_schema (1508 origin,1509 collection_id: CollectionId,1510 schema: Vec<u8>1511 ) -> DispatchResult {1512 let sender = ensure_signed(origin)?;1513 let mut target_collection = Self::get_collection(collection_id)?;1514 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15151516 // check schema limit1517 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15181519 target_collection.const_on_chain_schema = schema;1520 Self::save_collection(target_collection);15211522 Ok(())1523 }15241525 /// Set variable on-chain data schema.1526 /// 1527 /// # Permissions1528 /// 1529 /// * Collection Owner1530 /// * Collection Admin1531 /// 1532 /// # Arguments1533 /// 1534 /// * collection_id.1535 /// 1536 /// * schema: String representing the variable on-chain data schema.1537 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1538 #[transactional]1539 pub fn set_variable_on_chain_schema (1540 origin,1541 collection_id: CollectionId,1542 schema: Vec<u8>1543 ) -> DispatchResult {1544 let sender = ensure_signed(origin)?;1545 let mut target_collection = Self::get_collection(collection_id)?;1546 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15471548 // check schema limit1549 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15501551 target_collection.variable_on_chain_schema = schema;1552 Self::save_collection(target_collection);15531554 Ok(())1555 }15561557 // Sudo permissions function1558 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1559 #[transactional]1560 pub fn set_chain_limits(1561 origin,1562 limits: ChainLimits1563 ) -> DispatchResult {15641565 #[cfg(not(feature = "runtime-benchmarks"))]1566 ensure_root(origin)?;15671568 <ChainLimit>::put(limits);1569 Ok(())1570 }15711572 /// Enable smart contract self-sponsoring.1573 /// 1574 /// # Permissions1575 /// 1576 /// * Contract Owner1577 /// 1578 /// # Arguments1579 /// 1580 /// * contract address1581 /// * enable flag1582 /// 1583 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1584 #[transactional]1585 pub fn enable_contract_sponsoring(1586 origin,1587 contract_address: T::AccountId,1588 enable: bool1589 ) -> DispatchResult {15901591 let sender = ensure_signed(origin)?;15921593 #[cfg(feature = "runtime-benchmarks")]1594 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15951596 Self::ensure_contract_owned(sender, &contract_address)?;15971598 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1599 Ok(())1600 }16011602 /// Set the rate limit for contract sponsoring to specified number of blocks.1603 /// 1604 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1605 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1606 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1607 /// from contract endowment if there are at least B blocks between such transactions. 1608 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1609 /// 1610 /// # Permissions1611 /// 1612 /// * Contract Owner1613 /// 1614 /// # Arguments1615 /// 1616 /// -`contract_address`: Address of the contract to sponsor1617 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1618 /// 1619 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1620 #[transactional]1621 pub fn set_contract_sponsoring_rate_limit(1622 origin,1623 contract_address: T::AccountId,1624 rate_limit: T::BlockNumber1625 ) -> DispatchResult {1626 let sender = ensure_signed(origin)?;16271628 #[cfg(feature = "runtime-benchmarks")]1629 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16301631 Self::ensure_contract_owned(sender, &contract_address)?;1632 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1633 Ok(())1634 }16351636 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1637 /// 1638 /// # Permissions1639 /// 1640 /// * Address that deployed smart contract.1641 /// 1642 /// # Arguments1643 /// 1644 /// -`contract_address`: Address of the contract.1645 /// 1646 /// - `enable`: . 1647 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1648 #[transactional]1649 pub fn toggle_contract_white_list(1650 origin,1651 contract_address: T::AccountId,1652 enable: bool1653 ) -> DispatchResult {1654 let sender = ensure_signed(origin)?;16551656 #[cfg(feature = "runtime-benchmarks")]1657 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16581659 Self::ensure_contract_owned(sender, &contract_address)?;1660 if enable {1661 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1662 } else {1663 <ContractWhiteListEnabled<T>>::remove(contract_address);1664 }1665 Ok(())1666 }1667 1668 /// Add an address to smart contract white list.1669 /// 1670 /// # Permissions1671 /// 1672 /// * Address that deployed smart contract.1673 /// 1674 /// # Arguments1675 /// 1676 /// -`contract_address`: Address of the contract.1677 ///1678 /// -`account_address`: Address to add.1679 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1680 #[transactional]1681 pub fn add_to_contract_white_list(1682 origin,1683 contract_address: T::AccountId,1684 account_address: T::AccountId1685 ) -> DispatchResult {1686 let sender = ensure_signed(origin)?;16871688 #[cfg(feature = "runtime-benchmarks")]1689 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1690 1691 Self::ensure_contract_owned(sender, &contract_address)?; 1692 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1693 Ok(())1694 }16951696 /// Remove an address from smart contract white list.1697 /// 1698 /// # Permissions1699 /// 1700 /// * Address that deployed smart contract.1701 /// 1702 /// # Arguments1703 /// 1704 /// -`contract_address`: Address of the contract.1705 ///1706 /// -`account_address`: Address to remove.1707 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1708 #[transactional]1709 pub fn remove_from_contract_white_list(1710 origin,1711 contract_address: T::AccountId,1712 account_address: T::AccountId1713 ) -> DispatchResult {1714 let sender = ensure_signed(origin)?;17151716 #[cfg(feature = "runtime-benchmarks")]1717 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17181719 Self::ensure_contract_owned(sender, &contract_address)?;1720 <ContractWhiteList<T>>::remove(contract_address, account_address);1721 Ok(())1722 }17231724 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1725 #[transactional]1726 pub fn set_collection_limits(1727 origin,1728 collection_id: u32,1729 new_limits: CollectionLimits<T::BlockNumber>,1730 ) -> DispatchResult {1731 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1732 let mut target_collection = Self::get_collection(collection_id)?;1733 Self::check_owner_permissions(&target_collection, sender.clone())?;1734 let old_limits = &target_collection.limits;1735 let chain_limits = ChainLimit::get();17361737 // collection bounds1738 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1739 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1740 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1741 Error::<T>::CollectionLimitBoundsExceeded);17421743 // token_limit check prev1744 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1745 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17461747 ensure!(1748 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1749 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1750 Error::<T>::OwnerPermissionsCantBeReverted,1751 );17521753 target_collection.limits = new_limits;1754 Self::save_collection(target_collection);17551756 Ok(())1757 } 1758 }1759}17601761impl<T: Config> Module<T> {17621763 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1764 // Limits check1765 Self::is_correct_transfer(target_collection, &recipient)?;17661767 // Transfer permissions check1768 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1769 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1770 Error::<T>::NoPermission);17711772 if target_collection.access == AccessMode::WhiteList {1773 Self::check_white_list(target_collection, &sender)?;1774 Self::check_white_list(target_collection, &recipient)?;1775 }17761777 match target_collection.mode1778 {1779 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1780 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1781 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1782 _ => ()1783 };17841785 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17861787 Ok(())1788 }17891790 pub fn approve_internal(1791 sender: T::AccountId,1792 spender: T::AccountId,1793 collection: &CollectionHandle<T>,1794 item_id: TokenId,1795 amount: u1281796 ) -> DispatchResult {1797 Self::token_exists(&collection, item_id)?;17981799 // Transfer permissions check1800 let bypasses_limits = collection.limits.owner_can_transfer &&1801 Self::is_owner_or_admin_permissions(1802 &collection,1803 sender.clone(),1804 );18051806 let allowance_limit = if bypasses_limits {1807 None1808 } else if let Some(amount) = Self::owned_amount(1809 sender.clone(),1810 &collection,1811 item_id,1812 ) {1813 Some(amount)1814 } else {1815 fail!(Error::<T>::NoPermission);1816 };18171818 if collection.access == AccessMode::WhiteList {1819 Self::check_white_list(&collection, &sender)?;1820 Self::check_white_list(&collection, &spender)?;1821 }18221823 let allowance: u128 = amount1824 .checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1825 .ok_or(Error::<T>::NumOverflow)?;1826 if let Some(limit) = allowance_limit {1827 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1828 }1829 <Allowances<T>>::insert(collection.id, (item_id, sender.clone(), spender.clone()), allowance);18301831 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1832 Ok(())1833 }18341835 pub fn transfer_from_internal(1836 sender: T::AccountId,1837 from: T::AccountId,1838 recipient: T::AccountId,1839 collection: &CollectionHandle<T>,1840 item_id: TokenId,1841 amount: u128,1842 ) -> DispatchResult {1843 // Check approval1844 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));18451846 // Limits check1847 Self::is_correct_transfer(&collection, &recipient)?;18481849 // Transfer permissions check1850 ensure!(1851 approval >= amount || 1852 (1853 collection.limits.owner_can_transfer &&1854 Self::is_owner_or_admin_permissions(&collection, sender.clone())1855 ),1856 Error::<T>::NoPermission1857 );18581859 if collection.access == AccessMode::WhiteList {1860 Self::check_white_list(&collection, &sender)?;1861 Self::check_white_list(&collection, &recipient)?;1862 }18631864 // Reduce approval by transferred amount or remove if remaining approval drops to 01865 if approval.saturating_sub(amount) > 0 {1866 <Allowances<T>>::insert(collection.id, (item_id, &from, &sender), approval - amount);1867 } else {1868 <Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1869 }18701871 match collection.mode {1872 CollectionMode::NFT => {1873 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1874 }1875 CollectionMode::Fungible(_) => {1876 Self::transfer_fungible(&collection, amount, &from, &recipient)?1877 }1878 CollectionMode::ReFungible => {1879 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1880 }1881 _ => ()1882 };18831884 pub fn create_multiple_items_internal(1885 sender: T::CrossAccountId,1886 collection: &CollectionHandle<T>,1887 owner: T::CrossAccountId,1888 items_data: Vec<CreateItemData>,1889 ) -> DispatchResult {1890 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18911892 for data in &items_data {1893 Self::validate_create_item_args(&collection, data)?;1894 }1895 for data in &items_data {1896 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1897 }18981899 Ok(())1900 }19011902 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1903 let collection_id = collection.id;19041905 // check token limit and account token limit1906 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1907 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1908 1909 Ok(())1910 }19111912 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1913 let collection_id = collection.id;19141915 // check token limit and account token limit1916 let total_items: u32 = ItemListIndex::get(collection_id)1917 .checked_add(amount)1918 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1919 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1920 .checked_add(amount)1921 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1922 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1923 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);19241925 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1926 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1927 Self::check_white_list(collection, owner)?;1928 Self::check_white_list(collection, sender)?;1929 }19301931 Ok(())1932 }19331934 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1935 match target_collection.mode1936 {1937 CollectionMode::NFT => {1938 if let CreateItemData::NFT(data) = data {1939 // check sizes1940 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1941 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1942 } else {1943 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1944 }1945 },1946 CollectionMode::Fungible(_) => {1947 if let CreateItemData::Fungible(_) = data {1948 } else {1949 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1950 }1951 },1952 CollectionMode::ReFungible => {1953 if let CreateItemData::ReFungible(data) = data {19541955 // check sizes1956 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1957 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19581959 // Check refungibility limits1960 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1961 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1962 } else {1963 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1964 }1965 },1966 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1967 };19681969 Ok(())1970 }19711972 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1973 match data1974 {1975 CreateItemData::NFT(data) => {1976 let item = NftItemType {1977 owner: owner.clone(),1978 const_data: data.const_data,1979 variable_data: data.variable_data1980 };19811982 Self::add_nft_item(collection, item)?;1983 },1984 CreateItemData::Fungible(data) => {1985 Self::add_fungible_item(collection, &owner, data.value)?;1986 },1987 CreateItemData::ReFungible(data) => {1988 let mut owner_list = Vec::new();1989 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19901991 let item = ReFungibleItemType {1992 owner: owner_list,1993 const_data: data.const_data,1994 variable_data: data.variable_data1995 };19961997 Self::add_refungible_item(collection, item)?;1998 }1999 };20002001 Ok(())2002 }20032004 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {2005 let collection_id = collection.id;20062007 // Does new owner already have an account?2008 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;20092010 // Mint 2011 let item = FungibleItemType {2012 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,2013 };2014 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);20152016 // Update balance2017 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2018 .checked_add(value)2019 .ok_or(Error::<T>::NumOverflow)?;2020 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20212022 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2023 Ok(())2024 }20252026 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {2027 let collection_id = collection.id;20282029 let current_index = <ItemListIndex>::get(collection_id)2030 .checked_add(1)2031 .ok_or(Error::<T>::NumOverflow)?;2032 let itemcopy = item.clone();20332034 ensure!(2035 item.owner.len() == 1,2036 Error::<T>::BadCreateRefungibleCall,2037 );2038 let item_owner = item.owner.first().expect("only one owner is defined");20392040 let value = item_owner.fraction;2041 let owner = item_owner.owner.clone();20422043 Self::add_token_index(collection_id, current_index, &owner)?;20442045 <ItemListIndex>::insert(collection_id, current_index);2046 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20472048 // Update balance2049 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2050 .checked_add(value)2051 .ok_or(Error::<T>::NumOverflow)?;2052 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20532054 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2055 Ok(())2056 }20572058 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2059 let collection_id = collection.id;20602061 let current_index = <ItemListIndex>::get(collection_id)2062 .checked_add(1)2063 .ok_or(Error::<T>::NumOverflow)?;20642065 let item_owner = item.owner.clone();2066 Self::add_token_index(collection_id, current_index, &item.owner)?;20672068 <ItemListIndex>::insert(collection_id, current_index);2069 <NftItemList<T>>::insert(collection_id, current_index, item);20702071 // Update balance2072 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2073 .checked_add(1)2074 .ok_or(Error::<T>::NumOverflow)?;2075 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);20762077 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2078 Ok(())2079 }20802081 fn burn_refungible_item(2082 collection: &CollectionHandle<T>,2083 item_id: TokenId,2084 owner: &T::AccountId,2085 ) -> DispatchResult {2086 let collection_id = collection.id;20872088 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2089 .ok_or(Error::<T>::TokenNotFound)?;2090 let rft_balance = token2091 .owner2092 .iter()2093 .find(|&i| i.owner == *owner)2094 .ok_or(Error::<T>::TokenNotFound)?;2095 Self::remove_token_index(collection_id, item_id, owner)?;20962097 // update balance2098 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())2099 .checked_sub(rft_balance.fraction)2100 .ok_or(Error::<T>::NumOverflow)?;2101 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);21022103 // Re-create owners list with sender removed2104 let index = token2105 .owner2106 .iter()2107 .position(|i| i.owner == *owner)2108 .expect("owned item is exists");2109 token.owner.remove(index);2110 let owner_count = token.owner.len();21112112 // Burn the token completely if this was the last (only) owner2113 if owner_count == 0 {2114 <ReFungibleItemList<T>>::remove(collection_id, item_id);2115 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2116 }2117 else {2118 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2119 }21202121 Ok(())2122 }21232124 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2125 let collection_id = collection.id;21262127 let item = <NftItemList<T>>::get(collection_id, item_id)2128 .ok_or(Error::<T>::TokenNotFound)?;2129 Self::remove_token_index(collection_id, item_id, &item.owner)?;21302131 // update balance2132 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2133 .checked_sub(1)2134 .ok_or(Error::<T>::NumOverflow)?;2135 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2136 <NftItemList<T>>::remove(collection_id, item_id);2137 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21382139 Ok(())2140 }21412142 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2143 let collection_id = collection.id;21442145 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2146 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21472148 // update balance2149 let new_balance = <Balance<T>>::get(collection_id, owner)2150 .checked_sub(value)2151 .ok_or(Error::<T>::NumOverflow)?;2152 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);21532154 if balance.value - value > 0 {2155 balance.value -= value;2156 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2157 }2158 else {2159 <FungibleItemList<T>>::remove(collection_id, owner);2160 }21612162 Ok(())2163 }21642165 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2166 Ok(<CollectionById<T>>::get(collection_id)2167 .map(|collection| CollectionHandle {2168 id: collection_id,2169 collection2170 })2171 .ok_or(Error::<T>::CollectionNotFound)?)2172 }21732174 fn save_collection(collection: CollectionHandle<T>) {2175 <CollectionById<T>>::insert(collection.id, collection.collection);2176 }21772178 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2179 ensure!(2180 subject == target_collection.owner,2181 Error::<T>::NoPermission2182 );21832184 Ok(())2185 }21862187 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2188 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2189 }21902191 fn check_owner_or_admin_permissions(2192 collection: &CollectionHandle<T>,2193 subject: T::AccountId,2194 ) -> DispatchResult {2195 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21962197 Ok(())2198 }21992200 fn owned_amount(2201 subject: T::AccountId,2202 target_collection: &CollectionHandle<T>,2203 item_id: TokenId,2204 ) -> Option<u128> {2205 let collection_id = target_collection.id;22062207 match target_collection.mode {2208 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2209 .then(|| 1),2210 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2211 .value),2212 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2213 .owner2214 .iter()2215 .find(|i| i.owner == subject)2216 .map(|i| i.fraction),2217 CollectionMode::Invalid => None,2218 }2219 }22202221 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2222 match target_collection.mode {2223 CollectionMode::Fungible(_) => true,2224 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2225 }2226 }22272228 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2229 let collection_id = collection.id;22302231 let mes = Error::<T>::AddresNotInWhiteList;2232 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);22332234 Ok(())2235 }22362237 /// Check if token exists. In case of Fungible, check if there is an entry for 2238 /// the owner in fungible balances double map2239 fn token_exists(2240 target_collection: &CollectionHandle<T>,2241 item_id: TokenId,2242 ) -> DispatchResult {2243 let collection_id = target_collection.id;2244 let exists = match target_collection.mode2245 {2246 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2247 CollectionMode::Fungible(_) => true,2248 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2249 _ => false2250 };22512252 ensure!(exists == true, Error::<T>::TokenNotFound);2253 Ok(())2254 }22552256 fn transfer_fungible(2257 collection: &CollectionHandle<T>,2258 value: u128,2259 owner: &T::AccountId,2260 recipient: &T::AccountId,2261 ) -> DispatchResult {2262 let collection_id = collection.id;22632264 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2265 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22662267 // Send balance to recipient (updates balanceOf of recipient)2268 Self::add_fungible_item(collection, recipient, value)?;22692270 // update balanceOf of sender2271 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22722273 // Reduce or remove sender2274 if balance.value == value {2275 <FungibleItemList<T>>::remove(collection_id, owner);2276 }2277 else {2278 balance.value -= value;2279 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2280 }22812282 Ok(())2283 }22842285 fn transfer_refungible(2286 collection: &CollectionHandle<T>,2287 item_id: TokenId,2288 value: u128,2289 owner: T::AccountId,2290 new_owner: T::AccountId,2291 ) -> DispatchResult {2292 let collection_id = collection.id;2293 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2294 .ok_or(Error::<T>::TokenNotFound)?;22952296 let item = full_item2297 .owner2298 .iter()2299 .filter(|i| i.owner == owner)2300 .next()2301 .ok_or(Error::<T>::TokenNotFound)?;2302 let amount = item.fraction;23032304 ensure!(amount >= value, Error::<T>::TokenValueTooLow);23052306 // update balance2307 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2308 .checked_sub(value)2309 .ok_or(Error::<T>::NumOverflow)?;2310 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23112312 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2313 .checked_add(value)2314 .ok_or(Error::<T>::NumOverflow)?;2315 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);23162317 let old_owner = item.owner.clone();2318 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);23192320 // transfer2321 if amount == value && !new_owner_has_account {2322 // change owner2323 // new owner do not have account2324 let mut new_full_item = full_item.clone();2325 new_full_item2326 .owner2327 .iter_mut()2328 .find(|i| i.owner == owner)2329 .expect("old owner does present in refungible")2330 .owner = new_owner.clone();2331 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23322333 // update index collection2334 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2335 } else {2336 let mut new_full_item = full_item.clone();2337 new_full_item2338 .owner2339 .iter_mut()2340 .find(|i| i.owner == owner)2341 .expect("old owner does present in refungible")2342 .fraction -= value;23432344 // separate amount2345 if new_owner_has_account {2346 // new owner has account2347 new_full_item2348 .owner2349 .iter_mut()2350 .find(|i| i.owner == new_owner)2351 .expect("new owner has account")2352 .fraction += value;2353 } else {2354 // new owner do not have account2355 new_full_item.owner.push(Ownership {2356 owner: new_owner.clone(),2357 fraction: value,2358 });2359 Self::add_token_index(collection_id, item_id, &new_owner)?;2360 }23612362 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2363 }23642365 Ok(())2366 }23672368 fn transfer_nft(2369 collection: &CollectionHandle<T>,2370 item_id: TokenId,2371 sender: T::AccountId,2372 new_owner: T::AccountId,2373 ) -> DispatchResult {2374 let collection_id = collection.id;2375 let mut item = <NftItemList<T>>::get(collection_id, item_id)2376 .ok_or(Error::<T>::TokenNotFound)?;23772378 ensure!(2379 sender == item.owner,2380 Error::<T>::MustBeTokenOwner2381 );23822383 // update balance2384 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2385 .checked_sub(1)2386 .ok_or(Error::<T>::NumOverflow)?;2387 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23882389 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2390 .checked_add(1)2391 .ok_or(Error::<T>::NumOverflow)?;2392 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);23932394 // change owner2395 let old_owner = item.owner.clone();2396 item.owner = new_owner.clone();2397 <NftItemList<T>>::insert(collection_id, item_id, item);23982399 // update index collection2400 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;24012402 Ok(())2403 }2404 2405 fn set_re_fungible_variable_data(2406 collection: &CollectionHandle<T>,2407 item_id: TokenId,2408 data: Vec<u8>2409 ) -> DispatchResult {2410 let collection_id = collection.id;2411 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2412 .ok_or(Error::<T>::TokenNotFound)?;24132414 item.variable_data = data;24152416 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24172418 Ok(())2419 }24202421 fn set_nft_variable_data(2422 collection: &CollectionHandle<T>,2423 item_id: TokenId,2424 data: Vec<u8>2425 ) -> DispatchResult {2426 let collection_id = collection.id;2427 let mut item = <NftItemList<T>>::get(collection_id, item_id)2428 .ok_or(Error::<T>::TokenNotFound)?;2429 2430 item.variable_data = data;24312432 <NftItemList<T>>::insert(collection_id, item_id, item);2433 2434 Ok(())2435 }24362437 fn init_collection(item: &Collection<T>) {2438 // check params2439 assert!(2440 item.decimal_points <= MAX_DECIMAL_POINTS,2441 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2442 );2443 assert!(2444 item.name.len() <= 64,2445 "Collection name can not be longer than 63 char"2446 );2447 assert!(2448 item.name.len() <= 256,2449 "Collection description can not be longer than 255 char"2450 );2451 assert!(2452 item.token_prefix.len() <= 16,2453 "Token prefix can not be longer than 15 char"2454 );24552456 // Generate next collection ID2457 let next_id = CreatedCollectionCount::get()2458 .checked_add(1)2459 .unwrap();24602461 CreatedCollectionCount::put(next_id);2462 }24632464 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2465 let current_index = <ItemListIndex>::get(collection_id)2466 .checked_add(1)2467 .unwrap();24682469 let item_owner = item.owner.clone();2470 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24712472 <ItemListIndex>::insert(collection_id, current_index);24732474 // Update balance2475 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2476 .checked_add(1)2477 .unwrap();2478 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2479 }24802481 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2482 let current_index = <ItemListIndex>::get(collection_id)2483 .checked_add(1)2484 .unwrap();24852486 Self::add_token_index(collection_id, current_index, owner).unwrap();24872488 <ItemListIndex>::insert(collection_id, current_index);24892490 // Update balance2491 let new_balance = <Balance<T>>::get(collection_id, owner)2492 .checked_add(item.value)2493 .unwrap();2494 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2495 }24962497 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2498 let current_index = <ItemListIndex>::get(collection_id)2499 .checked_add(1)2500 .unwrap();25012502 let value = item.owner.first().unwrap().fraction;2503 let owner = item.owner.first().unwrap().owner.clone();25042505 Self::add_token_index(collection_id, current_index, &owner).unwrap();25062507 <ItemListIndex>::insert(collection_id, current_index);25082509 // Update balance2510 let new_balance = <Balance<T>>::get(collection_id, &owner)2511 .checked_add(value)2512 .unwrap();2513 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2514 }25152516 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2517 // add to account limit2518 if <AccountItemCount<T>>::contains_key(owner) {25192520 // bound Owned tokens by a single address2521 let count = <AccountItemCount<T>>::get(owner);2522 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25232524 <AccountItemCount<T>>::insert(owner.clone(), count2525 .checked_add(1)2526 .ok_or(Error::<T>::NumOverflow)?);2527 }2528 else {2529 <AccountItemCount<T>>::insert(owner.clone(), 1);2530 }25312532 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2533 if list_exists {2534 let mut list = <AddressTokens<T>>::get(collection_id, owner);2535 let item_contains = list.contains(&item_index.clone());25362537 if !item_contains {2538 list.push(item_index.clone());2539 }25402541 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2542 } else {2543 let mut itm = Vec::new();2544 itm.push(item_index.clone());2545 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2546 }25472548 Ok(())2549 }25502551 fn remove_token_index(2552 collection_id: CollectionId,2553 item_index: TokenId,2554 owner: &T::AccountId,2555 ) -> DispatchResult {25562557 // update counter2558 <AccountItemCount<T>>::insert(owner.clone(), 2559 <AccountItemCount<T>>::get(owner)2560 .checked_sub(1)2561 .ok_or(Error::<T>::NumOverflow)?);256225632564 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2565 if list_exists {2566 let mut list = <AddressTokens<T>>::get(collection_id, owner);2567 let item_contains = list.contains(&item_index.clone());25682569 if item_contains {2570 list.retain(|&item| item != item_index);2571 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2572 }2573 }25742575 Ok(())2576 }25772578 fn move_token_index(2579 collection_id: CollectionId,2580 item_index: TokenId,2581 old_owner: &T::AccountId,2582 new_owner: &T::AccountId,2583 ) -> DispatchResult {2584 Self::remove_token_index(collection_id, item_index, old_owner)?;2585 Self::add_token_index(collection_id, item_index, new_owner)?;25862587 Ok(())2588 }2589 2590 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2591 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25922593 Ok(())2594 }2595}25962597////////////////////////////////////////////////////////////////////////////////////////////////////2598// Economic models2599// #region26002601/// Fee multiplier.2602pub type Multiplier = FixedU128;26032604type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;26052606/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2607/// in the queue.2608#[derive(Encode, Decode, Clone, Eq, PartialEq)]2609pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);26102611impl<T: Config + Send + Sync> sp_std::fmt::Debug 2612 for ChargeTransactionPayment<T>2613{2614 #[cfg(feature = "std")]2615 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2616 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2617 }2618 #[cfg(not(feature = "std"))]2619 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2620 Ok(())2621 }2622}26232624impl<T: Config> ChargeTransactionPayment<T>2625where2626 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2627 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2628 T::AccountId: AsRef<[u8]>,2629 T::AccountId: UncheckedFrom<T::Hash>,2630{2631 fn traditional_fee(2632 len: usize,2633 info: &DispatchInfoOf<T::Call>,2634 tip: BalanceOf<T>,2635 ) -> BalanceOf<T>2636 where2637 T::Call: Dispatchable<Info = DispatchInfo>,2638 {2639 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2640 }26412642 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2643 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2644 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2645 let len_saturation = max_block_length as u64 / (len as u64).max(1);2646 let coefficient: BalanceOf<T> = weight_saturation2647 .min(len_saturation)2648 .saturated_into::<BalanceOf<T>>();2649 final_fee2650 .saturating_mul(coefficient)2651 .saturated_into::<TransactionPriority>()2652 }26532654 fn withdraw_fee(2655 &self,2656 who: &T::AccountId,2657 call: &T::Call,2658 info: &DispatchInfoOf<T::Call>,2659 len: usize,2660 ) -> Result<2661 (2662 BalanceOf<T>,2663 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2664 ),2665 TransactionValidityError,2666 > {2667 let tip = self.0;26682669 let fee = Self::traditional_fee(len, info, tip);26702671 // Only mess with balances if fee is not zero.2672 if fee.is_zero() {2673 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2674 .map(|i| (fee, i));2675 }26762677 // Determine who is paying transaction fee based on ecnomic model2678 // Parse call to extract collection ID and access collection sponsor2679 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2680 Some(Call::create_item(collection_id, _owner, _properties)) => {2681 let collection = <CollectionById<T>>::get(collection_id)?;26822683 // sponsor timeout2684 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26852686 let limit = collection.limits.sponsor_transfer_timeout;2687 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2688 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2689 let limit_time = last_tx_block + limit.into();2690 if block_number <= limit_time {2691 return None;2692 }2693 }2694 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26952696 // check free create limit2697 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2698 collection.sponsorship.sponsor()2699 .cloned()2700 } else {2701 None2702 }2703 }2704 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2705 let collection = <CollectionById<T>>::get(collection_id)?;2706 2707 let mut sponsor_transfer = false;2708 if collection.sponsorship.confirmed() {27092710 let collection_limits = collection.limits;2711 let collection_mode = collection.mode;2712 2713 // sponsor timeout2714 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2715 sponsor_transfer = match collection_mode {2716 CollectionMode::NFT => {2717 2718 // get correct limit2719 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2720 collection_limits.sponsor_transfer_timeout2721 } else {2722 ChainLimit::get().nft_sponsor_transfer_timeout2723 };2724 2725 let mut sponsored = true;2726 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2727 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2728 let limit_time = last_tx_block + limit.into();2729 if block_number <= limit_time {2730 sponsored = false;2731 }2732 }2733 if sponsored {2734 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2735 }27362737 sponsored2738 }2739 CollectionMode::Fungible(_) => {2740 2741 // get correct limit2742 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2743 collection_limits.sponsor_transfer_timeout2744 } else {2745 ChainLimit::get().fungible_sponsor_transfer_timeout2746 };2747 2748 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2749 let mut sponsored = true;2750 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2751 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2752 let limit_time = last_tx_block + limit.into();2753 if block_number <= limit_time {2754 sponsored = false;2755 }2756 }2757 if sponsored {2758 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2759 }27602761 sponsored2762 }2763 CollectionMode::ReFungible => {2764 2765 // get correct limit2766 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2767 collection_limits.sponsor_transfer_timeout2768 } else {2769 ChainLimit::get().refungible_sponsor_transfer_timeout2770 };2771 2772 let mut sponsored = true;2773 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2774 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2775 let limit_time = last_tx_block + limit.into();2776 if block_number <= limit_time {2777 sponsored = false;2778 }2779 }2780 if sponsored {2781 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2782 }27832784 sponsored2785 }2786 _ => {2787 false2788 },2789 };2790 }27912792 if !sponsor_transfer {2793 None2794 } else {2795 collection.sponsorship.sponsor()2796 .cloned()2797 }2798 }27992800 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2801 let mut sponsor_metadata_changes = false;28022803 let collection = <CollectionById<T>>::get(collection_id)?;28042805 if2806 collection.sponsorship.confirmed() &&2807 // Can't sponsor fungible collection, this tx will be rejected2808 // as invalid2809 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2810 data.len() <= collection.limits.sponsored_data_size as usize2811 {2812 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2813 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;28142815 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2816 .map(|last_block| block_number - last_block > rate_limit)2817 .unwrap_or(true) 2818 {2819 sponsor_metadata_changes = true;2820 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2821 }2822 }2823 }28242825 if !sponsor_metadata_changes {2826 None2827 } else {2828 collection.sponsorship.sponsor().cloned()2829 }2830 }28312832 _ => None,2833 })();28342835 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2836 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28372838 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28392840 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2841 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2842 2843 if !owned_contract && white_list_enabled {2844 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2845 return Err(InvalidTransaction::Call.into());2846 }2847 }2848 },2849 _ => {},2850 }28512852 // Sponsor smart contracts2853 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28542855 // On instantiation: set the contract owner2856 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28572858 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2859 &who,2860 code_hash,2861 salt,2862 );2863 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28642865 None2866 },28672868 // On instantiation with code: set the contract owner2869 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28702871 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2872 &who,2873 &T::Hashing::hash(&_code),2874 _salt,2875 );28762877 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28782879 None2880 }28812882 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2883 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28842885 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28862887 let mut sponsor_transfer = false;2888 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2889 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2890 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2891 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2892 let limit_time = last_tx_block + rate_limit;28932894 if block_number >= limit_time {2895 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2896 sponsor_transfer = true;2897 }2898 } else {2899 sponsor_transfer = false;2900 }2901 2902 if sponsor_transfer {2903 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2904 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2905 return Some(called_contract);2906 }2907 }2908 }29092910 None2911 },29122913 _ => None,2914 });29152916 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());29172918 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2919 .map(|i| (fee, i))2920 }2921}292229232924impl<T: Config + Send + Sync> SignedExtension2925 for ChargeTransactionPayment<T>2926where2927 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2928 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2929 T::AccountId: AsRef<[u8]>,2930 T::AccountId: UncheckedFrom<T::Hash>,2931{2932 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2933 type AccountId = T::AccountId;2934 type Call = T::Call;2935 type AdditionalSigned = ();2936 type Pre = (2937 // tip2938 BalanceOf<T>,2939 // who pays fee2940 Self::AccountId,2941 // imbalance resulting from withdrawing the fee2942 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2943 );2944 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2945 Ok(())2946 }29472948 fn validate(2949 &self,2950 who: &Self::AccountId,2951 call: &Self::Call,2952 info: &DispatchInfoOf<Self::Call>,2953 len: usize,2954 ) -> TransactionValidity {2955 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2956 Ok(ValidTransaction {2957 priority: Self::get_priority(len, info, fee),2958 ..Default::default()2959 })2960 }29612962 fn pre_dispatch(2963 self,2964 who: &Self::AccountId,2965 call: &Self::Call,2966 info: &DispatchInfoOf<Self::Call>,2967 len: usize,2968 ) -> Result<Self::Pre, TransactionValidityError> {2969 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2970 Ok((self.0, who.clone(), imbalance))2971 }29722973 fn post_dispatch(2974 pre: Self::Pre,2975 info: &DispatchInfoOf<Self::Call>,2976 post_info: &PostDispatchInfoOf<Self::Call>,2977 len: usize,2978 _result: &DispatchResult,2979 ) -> Result<(), TransactionValidityError> {2980 let (tip, who, imbalance) = pre;2981 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2982 len as u32,2983 info,2984 post_info,2985 tip,2986 );2987 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2988 Ok(())2989 }2990}29912992// #endregion29932994sp_api::decl_runtime_apis! {2995 pub trait NftApi {2996 /// Used for ethereum integration2997 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2998 }2999}1//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 serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465// Structs66// #region6768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 // decimal points78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 /// The fees are applied to the transaction sender134 Disabled,135 Unconfirmed(AccountId),136 /// Transactions are sponsored by specified account137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, // 64 include null escape char174 pub description: Vec<u16>, // 256 include null escape char175 pub token_prefix: Vec<u8>, // 16 include null escape char176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::AccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 181 pub variable_on_chain_schema: Vec<u8>, //182 pub const_on_chain_schema: Vec<u8>, //183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191 type Target = Collection<T>;192193 fn deref(&self) -> &Self::Target {194 &self.collection195 }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199 fn deref_mut(&mut self) -> &mut Self::Target {200 &mut self.collection201 }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207 pub owner: AccountId,208 pub const_data: Vec<u8>,209 pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215 pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221 pub owner: Vec<Ownership<AccountId>>,222 pub const_data: Vec<u8>,223 pub variable_data: Vec<u8>,224}225226// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]227// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]228// pub struct VestingItem<AccountId, Moment> {229// pub sender: AccountId,230// pub recipient: AccountId,231// pub collection_id: CollectionId,232// pub item_id: TokenId,233// pub amount: u64,234// pub vesting_date: Moment,235// }236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240 pub account_token_ownership_limit: u32,241 pub sponsored_data_size: u32,242 /// None - setVariableMetadata is not sponsored243 /// Some(v) - setVariableMetadata is sponsored 244 /// if there is v block between txs245 pub sponsored_data_rate_limit: Option<BlockNumber>,246 pub token_limit: u32,247248 // Timeouts for item types in passed blocks249 pub sponsor_transfer_timeout: u32,250 pub owner_can_transfer: bool,251 pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255 fn default() -> Self {256 Self { 257 account_token_ownership_limit: 10_000_000, 258 token_limit: u32::max_value(),259 sponsored_data_size: u32::MAX, 260 sponsored_data_rate_limit: None,261 sponsor_transfer_timeout: 14400,262 owner_can_transfer: true,263 owner_can_destroy: true264 }265 }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271 pub collection_numbers_limit: u32,272 pub account_token_ownership_limit: u32,273 pub collections_admins_limit: u64,274 pub custom_data_limit: u32,275276 // Timeouts for item types in passed blocks277 pub nft_sponsor_transfer_timeout: u32,278 pub fungible_sponsor_transfer_timeout: u32,279 pub refungible_sponsor_transfer_timeout: u32,280281 // Schema limits282 pub offchain_schema_limit: u32,283 pub variable_on_chain_schema_limit: u32,284 pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288 fn create_collection() -> Weight;289 fn destroy_collection() -> Weight;290 fn add_to_white_list() -> Weight;291 fn remove_from_white_list() -> Weight;292 fn set_public_access_mode() -> Weight;293 fn set_mint_permission() -> Weight;294 fn change_collection_owner() -> Weight;295 fn add_collection_admin() -> Weight;296 fn remove_collection_admin() -> Weight;297 fn set_collection_sponsor() -> Weight;298 fn confirm_sponsorship() -> Weight;299 fn remove_collection_sponsor() -> Weight;300 fn create_item(s: usize) -> Weight;301 fn burn_item() -> Weight;302 fn transfer() -> Weight;303 fn approve() -> Weight;304 fn transfer_from() -> Weight;305 fn set_offchain_schema() -> Weight;306 fn set_const_on_chain_schema() -> Weight;307 fn set_variable_on_chain_schema() -> Weight;308 fn set_variable_meta_data() -> Weight;309 fn enable_contract_sponsoring() -> Weight;310 fn set_schema_version() -> Weight;311 fn set_chain_limits() -> Weight;312 fn set_contract_sponsoring_rate_limit() -> Weight;313 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314 fn toggle_contract_white_list() -> Weight;315 fn add_to_contract_white_list() -> Weight;316 fn remove_from_contract_white_list() -> Weight;317 fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323 pub const_data: Vec<u8>,324 pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330 pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336 pub const_data: Vec<u8>,337 pub variable_data: Vec<u8>,338 pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344 NFT(CreateNftData),345 Fungible(CreateFungibleData),346 ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350 pub fn len(&self) -> usize {351 let len = match self {352 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354 _ => 0355 };356 357 return len;358 }359}360361impl From<CreateNftData> for CreateItemData {362 fn from(item: CreateNftData) -> Self {363 CreateItemData::NFT(item)364 }365}366367impl From<CreateReFungibleData> for CreateItemData {368 fn from(item: CreateReFungibleData) -> Self {369 CreateItemData::ReFungible(item)370 }371}372373impl From<CreateFungibleData> for CreateItemData {374 fn from(item: CreateFungibleData) -> Self {375 CreateItemData::Fungible(item)376 }377}378379380decl_error! {381 /// Error for non-fungible-token module.382 pub enum Error for Module<T: Config> {383 /// Total collections bound exceeded.384 TotalCollectionsLimitExceeded,385 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.386 CollectionDecimalPointLimitExceeded, 387 /// Collection name can not be longer than 63 char.388 CollectionNameLimitExceeded, 389 /// Collection description can not be longer than 255 char.390 CollectionDescriptionLimitExceeded, 391 /// Token prefix can not be longer than 15 char.392 CollectionTokenPrefixLimitExceeded,393 /// This collection does not exist.394 CollectionNotFound,395 /// Item not exists.396 TokenNotFound,397 /// Admin not found398 AdminNotFound,399 /// Arithmetic calculation overflow.400 NumOverflow, 401 /// Account already has admin role.402 AlreadyAdmin, 403 /// You do not own this collection.404 NoPermission,405 /// This address is not set as sponsor, use setCollectionSponsor first.406 ConfirmUnsetSponsorFail,407 /// Collection is not in mint mode.408 PublicMintingNotAllowed,409 /// Sender parameter and item owner must be equal.410 MustBeTokenOwner,411 /// Item balance not enough.412 TokenValueTooLow,413 /// Size of item is too large.414 NftSizeLimitExceeded,415 /// No approve found416 ApproveNotFound,417 /// Requested value more than approved.418 TokenValueNotEnough,419 /// Only approved addresses can call this method.420 ApproveRequired,421 /// Address is not in white list.422 AddresNotInWhiteList,423 /// Number of collection admins bound exceeded.424 CollectionAdminsLimitExceeded,425 /// Owned tokens by a single address bound exceeded.426 AddressOwnershipLimitExceeded,427 /// Length of items properties must be greater than 0.428 EmptyArgument,429 /// const_data exceeded data limit.430 TokenConstDataLimitExceeded,431 /// variable_data exceeded data limit.432 TokenVariableDataLimitExceeded,433 /// Not NFT item data used to mint in NFT collection.434 NotNftDataUsedToMintNftCollectionToken,435 /// Not Fungible item data used to mint in Fungible collection.436 NotFungibleDataUsedToMintFungibleCollectionToken,437 /// Not Re Fungible item data used to mint in Re Fungible collection.438 NotReFungibleDataUsedToMintReFungibleCollectionToken,439 /// Unexpected collection type.440 UnexpectedCollectionType,441 /// Can't store metadata in fungible tokens.442 CantStoreMetadataInFungibleTokens,443 /// Collection token limit exceeded444 CollectionTokenLimitExceeded,445 /// Account token limit exceeded per collection446 AccountTokenLimitExceeded,447 /// Collection limit bounds per collection exceeded448 CollectionLimitBoundsExceeded,449 /// Tried to enable permissions which are only permitted to be disabled450 OwnerPermissionsCantBeReverted,451 /// Schema data size limit bound exceeded452 SchemaDataLimitExceeded,453 /// Maximum refungibility exceeded454 WrongRefungiblePieces,455 /// createRefungible should be called with one owner456 BadCreateRefungibleCall,457 }458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463 /// Weight information for extrinsics in this pallet.464 type WeightInfo: WeightInfo;465466 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470 type CrossAccountId: CrossAccountId<Self::AccountId>;471 type Currency: Currency<Self::AccountId>;472 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473 type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479// #endregion480481// # Used definitions482//483// ## User control levels484//485// chain-controlled - key is uncontrolled by user486// i.e autoincrementing index487// can use non-cryptographic hash488// real - key is controlled by user489// but it is hard to generate enough colliding values, i.e owner of signed txs490// can use non-cryptographic hash491// controlled - key is completly controlled by users492// i.e maps with mutable keys493// should use cryptographic hash494//495// ## User control level downgrade reasons496//497// ?1 - chain-controlled -> controlled498// collections/tokens can be destroyed, resulting in massive holes499// ?2 - chain-controlled -> controlled500// same as ?1, but can be only added, resulting in easier exploitation501// ?3 - real -> controlled502// no confirmation required, so addresses can be easily generated503decl_storage! {504 trait Store for Module<T: Config> as Nft {505506 //#region Private members507 /// Id of next collection508 CreatedCollectionCount: u32;509 /// Used for migrations510 ChainVersion: u64;511 /// Id of last collection token512 /// Collection id (controlled?1)513 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514 //#endregion515516 //#region Chain limits struct517 pub ChainLimit get(fn chain_limit) config(): ChainLimits;518 //#endregion519520 //#region Bound counters521 /// Amount of collections destroyed, used for total amount tracking with522 /// CreatedCollectionCount523 DestroyedCollectionCount: u32;524 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)525 /// Account id (real)526 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527 //#endregion528529 //#region Basic collections530 /// Collection info531 /// Collection id (controlled?1)532 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533 /// List of collection admins534 /// Collection id (controlled?2)535 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536 /// Whitelisted collection users537 /// Collection id (controlled?2), user id (controlled?3)538 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539 //#endregion540541 /// How many of collection items user have542 /// Collection id (controlled?2), account id (real)543 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545 /// Amount of items which spender can transfer out of owners account (via transferFrom)546 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))547 /// TODO: Off chain worker should remove from this map when token gets removed548 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550 //#region Item collections551 /// Collection id (controlled?2), token id (controlled?1)552 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553 /// Collection id (controlled?2), owner (controlled?2)554 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555 /// Collection id (controlled?2), token id (controlled?1)556 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557 //#endregion558559 //#region Index list560 /// Collection id (controlled?2), tokens owner (controlled?2)561 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562 //#endregion563564 //#region Tokens transfer rate limit baskets565 /// (Collection id (controlled?2), who created (real))566 /// TODO: Off chain worker should remove from this map when collection gets removed567 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568 /// Collection id (controlled?2), token id (controlled?2)569 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570 /// Collection id (controlled?2), owning user (real)571 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572 /// Collection id (controlled?2), token id (controlled?2)573 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574 //#endregion575576 /// Variable metadata sponsoring577 /// Collection id (controlled?2), token id (controlled?2)578 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579 580 //#region Contract Sponsorship and Ownership581 /// Contract address (real)582 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583 /// Contract address (real)584 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585 /// (Contract address(real), caller (real))586 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587 /// Contract address (real)588 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589 /// Contract address (real)590 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591 /// Contract address (real) => Whitelisted user (controlled?3)592 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593 //#endregion594 }595 add_extra_genesis {596 build(|config: &GenesisConfig<T>| {597 // Modification of storage598 for (_num, _c) in &config.collection_id {599 <Module<T>>::init_collection(_c);600 }601602 for (_num, _c, _i) in &config.nft_item_id {603 <Module<T>>::init_nft_token(*_c, _i);604 }605606 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);608 }609610 for (_num, _c, _i) in &config.refungible_item_id {611 <Module<T>>::init_refungible_token(*_c, _i);612 }613 })614 }615}616617decl_event!(618 pub enum Event<T>619 where620 CrossAccountId = <T as Config>::CrossAccountId,621 {622 /// New collection was created623 /// 624 /// # Arguments625 /// 626 /// * collection_id: Globally unique identifier of newly created collection.627 /// 628 /// * mode: [CollectionMode] converted into u8.629 /// 630 /// * account_id: Collection owner.631 CollectionCreated(CollectionId, u8, CrossAccountId),632633 /// New item was created.634 /// 635 /// # Arguments636 /// 637 /// * collection_id: Id of the collection where item was created.638 /// 639 /// * item_id: Id of an item. Unique within the collection.640 ///641 /// * recipient: Owner of newly created item 642 ItemCreated(CollectionId, TokenId, CrossAccountId),643644 /// Collection item was burned.645 /// 646 /// # Arguments647 /// 648 /// collection_id.649 /// 650 /// item_id: Identifier of burned NFT.651 ItemDestroyed(CollectionId, TokenId),652653 /// Item was transferred654 ///655 /// * collection_id: Id of collection to which item is belong656 ///657 /// * item_id: Id of an item658 ///659 /// * sender: Original owner of item660 ///661 /// * recipient: New owner of item662 ///663 /// * amount: Always 1 for NFT664 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666 /// * collection_id667 ///668 /// * item_id669 ///670 /// * sender671 ///672 /// * spender673 ///674 /// * amount675 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676 }677);678679decl_module! {680 pub struct Module<T: Config> for enum Call 681 where 682 origin: T::Origin683 {684 fn deposit_event() = default;685 type Error = Error<T>;686687 fn on_initialize(now: T::BlockNumber) -> Weight {688 0689 }690691 /// 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.692 /// 693 /// # Permissions694 /// 695 /// * Anyone.696 /// 697 /// # Arguments698 /// 699 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.700 /// 701 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.702 /// 703 /// * token_prefix: UTF-8 string with token prefix.704 /// 705 /// * mode: [CollectionMode] collection type and type dependent data.706 // returns collection ID707 #[weight = <T as Config>::WeightInfo::create_collection()]708 #[transactional]709 pub fn create_collection(origin,710 collection_name: Vec<u16>,711 collection_description: Vec<u16>,712 token_prefix: Vec<u8>,713 mode: CollectionMode) -> DispatchResult {714715 // Anyone can create a collection716 let who = T::CrossAccountId::from_sub(ensure_signed(origin)?);717718 // Take a (non-refundable) deposit of collection creation719 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721 &T::TreasuryAccountId::get(),722 T::CollectionCreationPrice::get(),723 ));724 <T as Config>::Currency::settle(725 who.as_sub(),726 imbalance,727 WithdrawReasons::TRANSFER,728 ExistenceRequirement::KeepAlive,729 ).map_err(|_| Error::<T>::NoPermission)?;730731 let decimal_points = match mode {732 CollectionMode::Fungible(points) => points,733 _ => 0734 };735736 let chain_limit = ChainLimit::get();737738 let created_count = CreatedCollectionCount::get();739 let destroyed_count = DestroyedCollectionCount::get();740741 // bound Total number of collections742 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744 // check params745 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750 // Generate next collection ID751 let next_id = created_count752 .checked_add(1)753 .ok_or(Error::<T>::NumOverflow)?;754755 CreatedCollectionCount::put(next_id);756757 let limits = CollectionLimits {758 sponsored_data_size: chain_limit.custom_data_limit,759 ..Default::default()760 };761762 // Create new collection763 let new_collection = Collection {764 owner: who.clone(),765 name: collection_name,766 mode: mode.clone(),767 mint_mode: false,768 access: AccessMode::Normal,769 description: collection_description,770 decimal_points: decimal_points,771 token_prefix: token_prefix,772 offchain_schema: Vec::new(),773 schema_version: SchemaVersion::ImageURL,774 sponsorship: SponsorshipState::Disabled,775 variable_on_chain_schema: Vec::new(),776 const_on_chain_schema: Vec::new(),777 limits,778 };779780 // Add new collection to map781 <CollectionById<T>>::insert(next_id, new_collection);782783 // call event784 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));785786 Ok(())787 }788789 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.790 /// 791 /// # Permissions792 /// 793 /// * Collection Owner.794 /// 795 /// # Arguments796 /// 797 /// * collection_id: collection to destroy.798 #[weight = <T as Config>::WeightInfo::destroy_collection()]799 #[transactional]800 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);803 let collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&collection, sender)?;805 if !collection.limits.owner_can_destroy {806 fail!(Error::<T>::NoPermission);807 }808809 <AddressTokens<T>>::remove_prefix(collection_id);810 <Allowances<T>>::remove_prefix(collection_id);811 <Balance<T>>::remove_prefix(collection_id);812 <ItemListIndex>::remove(collection_id);813 <AdminList<T>>::remove(collection_id);814 <CollectionById<T>>::remove(collection_id);815 <WhiteList<T>>::remove_prefix(collection_id);816817 <NftItemList<T>>::remove_prefix(collection_id);818 <FungibleItemList<T>>::remove_prefix(collection_id);819 <ReFungibleItemList<T>>::remove_prefix(collection_id);820821 <NftTransferBasket<T>>::remove_prefix(collection_id);822 <FungibleTransferBasket<T>>::remove_prefix(collection_id);823 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827 DestroyedCollectionCount::put(DestroyedCollectionCount::get()828 .checked_add(1)829 .ok_or(Error::<T>::NumOverflow)?);830831 Ok(())832 }833834 /// Add an address to white list.835 /// 836 /// # Permissions837 /// 838 /// * Collection Owner839 /// * Collection Admin840 /// 841 /// # Arguments842 /// 843 /// * collection_id.844 /// 845 /// * address.846 #[weight = <T as Config>::WeightInfo::add_to_white_list()]847 #[transactional]848 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{849850 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);851 let collection = Self::get_collection(collection_id)?;852 Self::check_owner_or_admin_permissions(&collection, sender)?;853854 <WhiteList<T>>::insert(collection_id, address.as_sub(), true);855 856 Ok(())857 }858859 /// Remove an address from white list.860 /// 861 /// # Permissions862 /// 863 /// * Collection Owner864 /// * Collection Admin865 /// 866 /// # Arguments867 /// 868 /// * collection_id.869 /// 870 /// * address.871 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872 #[transactional]873 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{874875 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876 let collection = Self::get_collection(collection_id)?;877 Self::check_owner_or_admin_permissions(&collection, sender)?;878879 <WhiteList<T>>::remove(collection_id, address.as_sub());880881 Ok(())882 }883884 /// Toggle between normal and white list access for the methods with access for `Anyone`.885 /// 886 /// # Permissions887 /// 888 /// * Collection Owner.889 /// 890 /// # Arguments891 /// 892 /// * collection_id.893 /// 894 /// * mode: [AccessMode]895 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896 #[transactional]897 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898 {899 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);900901 let mut target_collection = Self::get_collection(collection_id)?;902 Self::check_owner_permissions(&target_collection, sender)?;903 target_collection.access = mode;904 Self::save_collection(target_collection);905906 Ok(())907 }908909 /// Allows Anyone to create tokens if:910 /// * White List is enabled, and911 /// * Address is added to white list, and912 /// * This method was called with True parameter913 /// 914 /// # Permissions915 /// * Collection Owner916 ///917 /// # Arguments918 /// 919 /// * collection_id.920 /// 921 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.922 #[weight = <T as Config>::WeightInfo::set_mint_permission()]923 #[transactional]924 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925 {926 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);927928 let mut target_collection = Self::get_collection(collection_id)?;929 Self::check_owner_permissions(&target_collection, sender)?;930 target_collection.mint_mode = mint_permission;931 Self::save_collection(target_collection);932933 Ok(())934 }935936 /// Change the owner of the collection.937 /// 938 /// # Permissions939 /// 940 /// * Collection Owner.941 /// 942 /// # Arguments943 /// 944 /// * collection_id.945 /// 946 /// * new_owner.947 #[weight = <T as Config>::WeightInfo::change_collection_owner()]948 #[transactional]949 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::CrossAccountId) -> DispatchResult {950951 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);952 let mut target_collection = Self::get_collection(collection_id)?;953 Self::check_owner_permissions(&target_collection, sender)?;954 target_collection.owner = new_owner;955 Self::save_collection(target_collection);956957 Ok(())958 }959960 /// Adds an admin of the Collection.961 /// 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. 962 /// 963 /// # Permissions964 /// 965 /// * Collection Owner.966 /// * Collection Admin.967 /// 968 /// # Arguments969 /// 970 /// * collection_id: ID of the Collection to add admin for.971 /// 972 /// * new_admin_id: Address of new admin to add.973 #[weight = <T as Config>::WeightInfo::add_collection_admin()]974 #[transactional]975 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {976977 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);978 let collection = Self::get_collection(collection_id)?;979 Self::check_owner_or_admin_permissions(&collection, sender)?;980 let mut admin_arr = <AdminList<T>>::get(collection_id);981982 match admin_arr.binary_search(&new_admin_id) {983 Ok(_) => {},984 Err(idx) => {985 let limits = ChainLimit::get();986 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);987 admin_arr.insert(idx, new_admin_id);988 <AdminList<T>>::insert(collection_id, admin_arr);989 }990 }991 Ok(())992 }993994 /// 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.995 ///996 /// # Permissions997 /// 998 /// * Collection Owner.999 /// * Collection Admin.1000 /// 1001 /// # Arguments1002 /// 1003 /// * collection_id: ID of the Collection to remove admin for.1004 /// 1005 /// * account_id: Address of admin to remove.1006 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1007 #[transactional]1008 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {10091010 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1011 let collection = Self::get_collection(collection_id)?;1012 Self::check_owner_or_admin_permissions(&collection, sender)?;1013 let mut admin_arr = <AdminList<T>>::get(collection_id);10141015 match admin_arr.binary_search(&account_id) {1016 Ok(idx) => {1017 admin_arr.remove(idx);1018 <AdminList<T>>::insert(collection_id, admin_arr);1019 },1020 Err(_) => {}1021 }1022 Ok(())1023 }10241025 /// # Permissions1026 /// 1027 /// * Collection Owner1028 /// 1029 /// # Arguments1030 /// 1031 /// * collection_id.1032 /// 1033 /// * new_sponsor.1034 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1035 #[transactional]1036 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1037 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1038 let mut target_collection = Self::get_collection(collection_id)?;1039 Self::check_owner_permissions(&target_collection, &sender)?;10401041 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1042 Self::save_collection(target_collection);10431044 Ok(())1045 }10461047 /// # Permissions1048 /// 1049 /// * Sponsor.1050 /// 1051 /// # Arguments1052 /// 1053 /// * collection_id.1054 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1055 #[transactional]1056 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1057 let sender = ensure_signed(origin)?;10581059 let mut target_collection = Self::get_collection(collection_id)?;1060 ensure!(1061 target_collection.sponsorship.pending_sponsor() == Some(&sender),1062 Error::<T>::ConfirmUnsetSponsorFail1063 );10641065 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1066 Self::save_collection(target_collection);10671068 Ok(())1069 }10701071 /// Switch back to pay-per-own-transaction model.1072 ///1073 /// # Permissions1074 ///1075 /// * Collection owner.1076 /// 1077 /// # Arguments1078 /// 1079 /// * collection_id.1080 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1081 #[transactional]1082 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1083 let sender = ensure_signed(origin)?;10841085 let mut target_collection = Self::get_collection(collection_id)?;1086 Self::check_owner_permissions(&target_collection, sender)?;10871088 target_collection.sponsorship = SponsorshipState::Disabled;1089 Self::save_collection(target_collection);10901091 Ok(())1092 }10931094 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1095 /// 1096 /// # Permissions1097 /// 1098 /// * Collection Owner.1099 /// * Collection Admin.1100 /// * Anyone if1101 /// * White List is enabled, and1102 /// * Address is added to white list, and1103 /// * MintPermission is enabled (see SetMintPermission method)1104 /// 1105 /// # Arguments1106 /// 1107 /// * collection_id: ID of the collection.1108 /// 1109 /// * owner: Address, initial owner of the NFT.1110 ///1111 /// * data: Token data to store on chain.1112 // #[weight =1113 // (130_000_000 as Weight)1114 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1115 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1116 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11171118 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1119 #[transactional]1120 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {11211122 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124 let target_collection = Self::get_collection(collection_id)?;11251126 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1127 Self::validate_create_item_args(&target_collection, &data)?;1128 Self::create_item_no_validation(&target_collection, owner, data)?;11291130 Ok(())1131 }11321133 /// This method creates multiple items in a collection created with CreateCollection method.1134 /// 1135 /// # Permissions1136 /// 1137 /// * Collection Owner.1138 /// * Collection Admin.1139 /// * Anyone if1140 /// * White List is enabled, and1141 /// * Address is added to white list, and1142 /// * MintPermission is enabled (see SetMintPermission method)1143 /// 1144 /// # Arguments1145 /// 1146 /// * collection_id: ID of the collection.1147 /// 1148 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1149 /// 1150 /// * owner: Address, initial owner of the NFT.1151 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1152 .map(|data| { data.len() })1153 .sum())]1154 #[transactional]1155 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11561157 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1158 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1159 let collection = Self::get_collection(collection_id)?;11601161 Self::create_multiple_items_internal(sender, &collection, owner, items_data)?;11621163 Ok(())1164 }11651166 /// Destroys a concrete instance of NFT.1167 /// 1168 /// # Permissions1169 /// 1170 /// * Collection Owner.1171 /// * Collection Admin.1172 /// * Current NFT Owner.1173 /// 1174 /// # Arguments1175 /// 1176 /// * collection_id: ID of the collection.1177 /// 1178 /// * item_id: ID of NFT to burn.1179 #[weight = <T as Config>::WeightInfo::burn_item()]1180 #[transactional]1181 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11821183 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1184 let target_collection = Self::get_collection(collection_id)?;11851186 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;11871188 Ok(())1189 }11901191 /// Change ownership of the token.1192 /// 1193 /// # Permissions1194 /// 1195 /// * Collection Owner1196 /// * Collection Admin1197 /// * Current NFT owner1198 ///1199 /// # Arguments1200 /// 1201 /// * recipient: Address of token recipient.1202 /// 1203 /// * collection_id.1204 /// 1205 /// * item_id: ID of the item1206 /// * Non-Fungible Mode: Required.1207 /// * Fungible Mode: Ignored.1208 /// * Re-Fungible Mode: Required.1209 /// 1210 /// * value: Amount to transfer.1211 /// * Non-Fungible Mode: Ignored1212 /// * Fungible Mode: Must specify transferred amount1213 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1214 #[weight = <T as Config>::WeightInfo::transfer()]1215 #[transactional]1216 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1217 let sender = ensure_signed(origin)?;1218 let collection = Self::get_collection(collection_id)?;12191220 Self::transfer_internal(sender, recipient, &collection, item_id, value)1221 }12221223 /// Set, change, or remove approved address to transfer the ownership of the NFT.1224 /// 1225 /// # Permissions1226 /// 1227 /// * Collection Owner1228 /// * Collection Admin1229 /// * Current NFT owner1230 /// 1231 /// # Arguments1232 /// 1233 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1234 /// 1235 /// * collection_id.1236 /// 1237 /// * item_id: ID of the item.1238 #[weight = <T as Config>::WeightInfo::approve()]1239 #[transactional]1240 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12411242 let sender = ensure_signed(origin)?;1243 let target_collection = Self::get_collection(collection_id)?;12441245 Self::token_exists(&target_collection, item_id)?;12461247 // Transfer permissions check1248 let bypasses_limits = target_collection.limits.owner_can_transfer &&1249 Self::is_owner_or_admin_permissions(1250 &target_collection,1251 sender.clone(),1252 );12531254 let allowance_limit = if bypasses_limits {1255 None1256 } else if let Some(amount) = Self::owned_amount(1257 sender.clone(),1258 &target_collection,1259 item_id,1260 ) {1261 Some(amount)1262 } else {1263 fail!(Error::<T>::NoPermission);1264 };12651266 if target_collection.access == AccessMode::WhiteList {1267 Self::check_white_list(&target_collection, &sender)?;1268 Self::check_white_list(&target_collection, &spender)?;1269 }12701271 let allowance: u128 = amount1272 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1273 .ok_or(Error::<T>::NumOverflow)?;1274 if let Some(limit) = allowance_limit {1275 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1276 }1277 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);12781279 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1280 Ok(())1281 }1282 1283 /// 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.1284 /// 1285 /// # Permissions1286 /// * Collection Owner1287 /// * Collection Admin1288 /// * Current NFT owner1289 /// * Address approved by current NFT owner1290 /// 1291 /// # Arguments1292 /// 1293 /// * from: Address that owns token.1294 /// 1295 /// * recipient: Address of token recipient.1296 /// 1297 /// * collection_id.1298 /// 1299 /// * item_id: ID of the item.1300 /// 1301 /// * value: Amount to transfer.1302 #[weight = <T as Config>::WeightInfo::transfer_from()]1303 #[transactional]1304 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13051306 let sender = ensure_signed(origin)?;1307 let target_collection = Self::get_collection(collection_id)?;13081309 // Check approval1310 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13111312 // Limits check1313 Self::is_correct_transfer(&target_collection, &recipient)?;13141315 // Transfer permissions check 1316 ensure!(1317 approval >= value || 1318 (1319 target_collection.limits.owner_can_transfer &&1320 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1321 ),1322 Error::<T>::NoPermission1323 );13241325 if target_collection.access == AccessMode::WhiteList {1326 Self::check_white_list(&target_collection, &sender)?;1327 Self::check_white_list(&target_collection, &recipient)?;1328 }13291330 // Reduce approval by transferred amount or remove if remaining approval drops to 01331 if approval.saturating_sub(value) > 0 {1332 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1333 }1334 else {1335 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1336 }13371338 match target_collection.mode1339 {1340 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1341 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1342 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1343 _ => ()1344 };13451346 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1347 Ok(())1348 }13491350 // #[weight = 0]1351 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13521353 // // let no_perm_mes = "You do not have permissions to modify this collection";1354 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1355 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1356 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13571358 // // // on_nft_received call13591360 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13611362 // Ok(())1363 // }13641365 /// Set off-chain data schema.1366 /// 1367 /// # Permissions1368 /// 1369 /// * Collection Owner1370 /// * Collection Admin1371 /// 1372 /// # Arguments1373 /// 1374 /// * collection_id.1375 /// 1376 /// * schema: String representing the offchain data schema.1377 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1378 #[transactional]1379 pub fn set_variable_meta_data (1380 origin,1381 collection_id: CollectionId,1382 item_id: TokenId,1383 data: Vec<u8>1384 ) -> DispatchResult {1385 let sender = ensure_signed(origin)?;1386 1387 let target_collection = Self::get_collection(collection_id)?;1388 Self::token_exists(&target_collection, item_id)?;13891390 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13911392 // Modify permissions check1393 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1394 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1395 Error::<T>::NoPermission);13961397 match target_collection.mode1398 {1399 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1400 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1401 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1402 _ => fail!(Error::<T>::UnexpectedCollectionType)1403 };14041405 Ok(())1406 }1407 1408 /// Set schema standard1409 /// ImageURL1410 /// Unique1411 /// 1412 /// # Permissions1413 /// 1414 /// * Collection Owner1415 /// * Collection Admin1416 /// 1417 /// # Arguments1418 /// 1419 /// * collection_id.1420 /// 1421 /// * schema: SchemaVersion: enum1422 #[weight = <T as Config>::WeightInfo::set_schema_version()]1423 #[transactional]1424 pub fn set_schema_version(1425 origin,1426 collection_id: CollectionId,1427 version: SchemaVersion1428 ) -> DispatchResult {1429 let sender = ensure_signed(origin)?;1430 let mut target_collection = Self::get_collection(collection_id)?;1431 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1432 target_collection.schema_version = version;1433 Self::save_collection(target_collection);14341435 Ok(())1436 }14371438 /// Set off-chain data schema.1439 /// 1440 /// # Permissions1441 /// 1442 /// * Collection Owner1443 /// * Collection Admin1444 /// 1445 /// # Arguments1446 /// 1447 /// * collection_id.1448 /// 1449 /// * schema: String representing the offchain data schema.1450 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1451 #[transactional]1452 pub fn set_offchain_schema(1453 origin,1454 collection_id: CollectionId,1455 schema: Vec<u8>1456 ) -> DispatchResult {1457 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1458 let mut target_collection = Self::get_collection(collection_id)?;1459 Self::check_owner_or_admin_permissions(&target_collection, sender)?;14601461 // check schema limit1462 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14631464 target_collection.offchain_schema = schema;1465 Self::save_collection(target_collection);14661467 Ok(())1468 }14691470 /// Set const on-chain data schema.1471 /// 1472 /// # Permissions1473 /// 1474 /// * Collection Owner1475 /// * Collection Admin1476 /// 1477 /// # Arguments1478 /// 1479 /// * collection_id.1480 /// 1481 /// * schema: String representing the const on-chain data schema.1482 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1483 #[transactional]1484 pub fn set_const_on_chain_schema (1485 origin,1486 collection_id: CollectionId,1487 schema: Vec<u8>1488 ) -> DispatchResult {1489 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1490 let mut target_collection = Self::get_collection(collection_id)?;1491 Self::check_owner_or_admin_permissions(&target_collection, sender)?;14921493 // check schema limit1494 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14951496 target_collection.const_on_chain_schema = schema;1497 Self::save_collection(target_collection);14981499 Ok(())1500 }15011502 /// Set variable on-chain data schema.1503 /// 1504 /// # Permissions1505 /// 1506 /// * Collection Owner1507 /// * Collection Admin1508 /// 1509 /// # Arguments1510 /// 1511 /// * collection_id.1512 /// 1513 /// * schema: String representing the variable on-chain data schema.1514 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1515 #[transactional]1516 pub fn set_variable_on_chain_schema (1517 origin,1518 collection_id: CollectionId,1519 schema: Vec<u8>1520 ) -> DispatchResult {1521 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1522 let mut target_collection = Self::get_collection(collection_id)?;1523 Self::check_owner_or_admin_permissions(&target_collection, sender)?;15241525 // check schema limit1526 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15271528 target_collection.variable_on_chain_schema = schema;1529 Self::save_collection(target_collection);15301531 Ok(())1532 }15331534 // Sudo permissions function1535 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1536 #[transactional]1537 pub fn set_chain_limits(1538 origin,1539 limits: ChainLimits1540 ) -> DispatchResult {15411542 #[cfg(not(feature = "runtime-benchmarks"))]1543 ensure_root(origin)?;15441545 <ChainLimit>::put(limits);1546 Ok(())1547 }15481549 /// Enable smart contract self-sponsoring.1550 /// 1551 /// # Permissions1552 /// 1553 /// * Contract Owner1554 /// 1555 /// # Arguments1556 /// 1557 /// * contract address1558 /// * enable flag1559 /// 1560 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1561 #[transactional]1562 pub fn enable_contract_sponsoring(1563 origin,1564 contract_address: T::AccountId,1565 enable: bool1566 ) -> DispatchResult {15671568 let sender = ensure_signed(origin)?;15691570 #[cfg(feature = "runtime-benchmarks")]1571 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15721573 Self::ensure_contract_owned(sender, &contract_address)?;15741575 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1576 Ok(())1577 }15781579 /// Set the rate limit for contract sponsoring to specified number of blocks.1580 /// 1581 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1582 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1583 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1584 /// from contract endowment if there are at least B blocks between such transactions. 1585 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1586 /// 1587 /// # Permissions1588 /// 1589 /// * Contract Owner1590 /// 1591 /// # Arguments1592 /// 1593 /// -`contract_address`: Address of the contract to sponsor1594 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1595 /// 1596 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1597 #[transactional]1598 pub fn set_contract_sponsoring_rate_limit(1599 origin,1600 contract_address: T::AccountId,1601 rate_limit: T::BlockNumber1602 ) -> DispatchResult {1603 let sender = ensure_signed(origin)?;16041605 #[cfg(feature = "runtime-benchmarks")]1606 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16071608 Self::ensure_contract_owned(sender, &contract_address)?;1609 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1610 Ok(())1611 }16121613 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1614 /// 1615 /// # Permissions1616 /// 1617 /// * Address that deployed smart contract.1618 /// 1619 /// # Arguments1620 /// 1621 /// -`contract_address`: Address of the contract.1622 /// 1623 /// - `enable`: . 1624 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1625 #[transactional]1626 pub fn toggle_contract_white_list(1627 origin,1628 contract_address: T::AccountId,1629 enable: bool1630 ) -> DispatchResult {1631 let sender = ensure_signed(origin)?;16321633 #[cfg(feature = "runtime-benchmarks")]1634 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16351636 Self::ensure_contract_owned(sender, &contract_address)?;1637 if enable {1638 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1639 } else {1640 <ContractWhiteListEnabled<T>>::remove(contract_address);1641 }1642 Ok(())1643 }1644 1645 /// Add an address to smart contract white list.1646 /// 1647 /// # Permissions1648 /// 1649 /// * Address that deployed smart contract.1650 /// 1651 /// # Arguments1652 /// 1653 /// -`contract_address`: Address of the contract.1654 ///1655 /// -`account_address`: Address to add.1656 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1657 #[transactional]1658 pub fn add_to_contract_white_list(1659 origin,1660 contract_address: T::AccountId,1661 account_address: T::AccountId1662 ) -> DispatchResult {1663 let sender = ensure_signed(origin)?;16641665 #[cfg(feature = "runtime-benchmarks")]1666 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1667 1668 Self::ensure_contract_owned(sender, &contract_address)?; 1669 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1670 Ok(())1671 }16721673 /// Remove an address from smart contract white list.1674 /// 1675 /// # Permissions1676 /// 1677 /// * Address that deployed smart contract.1678 /// 1679 /// # Arguments1680 /// 1681 /// -`contract_address`: Address of the contract.1682 ///1683 /// -`account_address`: Address to remove.1684 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1685 #[transactional]1686 pub fn remove_from_contract_white_list(1687 origin,1688 contract_address: T::AccountId,1689 account_address: T::AccountId1690 ) -> DispatchResult {1691 let sender = ensure_signed(origin)?;16921693 #[cfg(feature = "runtime-benchmarks")]1694 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16951696 Self::ensure_contract_owned(sender, &contract_address)?;1697 <ContractWhiteList<T>>::remove(contract_address, account_address);1698 Ok(())1699 }17001701 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1702 #[transactional]1703 pub fn set_collection_limits(1704 origin,1705 collection_id: u32,1706 new_limits: CollectionLimits<T::BlockNumber>,1707 ) -> DispatchResult {1708 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1709 let mut target_collection = Self::get_collection(collection_id)?;1710 Self::check_owner_permissions(&target_collection, sender.clone())?;1711 let old_limits = &target_collection.limits;1712 let chain_limits = ChainLimit::get();17131714 // collection bounds1715 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1716 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1717 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1718 Error::<T>::CollectionLimitBoundsExceeded);17191720 // token_limit check prev1721 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1722 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17231724 ensure!(1725 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1726 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1727 Error::<T>::OwnerPermissionsCantBeReverted,1728 );17291730 target_collection.limits = new_limits;1731 Self::save_collection(target_collection);17321733 Ok(())1734 } 1735 }1736}17371738impl<T: Config> Module<T> {17391740 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1741 // Limits check1742 Self::is_correct_transfer(target_collection, &recipient)?;17431744 // Transfer permissions check1745 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1746 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1747 Error::<T>::NoPermission);17481749 if target_collection.access == AccessMode::WhiteList {1750 Self::check_white_list(target_collection, &sender)?;1751 Self::check_white_list(target_collection, &recipient)?;1752 }17531754 match target_collection.mode1755 {1756 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1757 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1758 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1759 _ => ()1760 };17611762 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17631764 Ok(())1765 }17661767 pub fn approve_internal(1768 sender: T::AccountId,1769 spender: T::AccountId,1770 collection: &CollectionHandle<T>,1771 item_id: TokenId,1772 amount: u1281773 ) -> DispatchResult {1774 Self::token_exists(&collection, item_id)?;17751776 // Transfer permissions check1777 let bypasses_limits = collection.limits.owner_can_transfer &&1778 Self::is_owner_or_admin_permissions(1779 &collection,1780 sender.clone(),1781 );17821783 let allowance_limit = if bypasses_limits {1784 None1785 } else if let Some(amount) = Self::owned_amount(1786 sender.clone(),1787 &collection,1788 item_id,1789 ) {1790 Some(amount)1791 } else {1792 fail!(Error::<T>::NoPermission);1793 };17941795 if collection.access == AccessMode::WhiteList {1796 Self::check_white_list(&collection, &sender)?;1797 Self::check_white_list(&collection, &spender)?;1798 }17991800 let allowance: u128 = amount1801 .checked_add(<Allowances<T>>::get(collection.id, (item_id, &sender, &spender)))1802 .ok_or(Error::<T>::NumOverflow)?;1803 if let Some(limit) = allowance_limit {1804 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1805 }1806 <Allowances<T>>::insert(collection.id, (item_id, sender.clone(), spender.clone()), allowance);18071808 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1809 Ok(())1810 }18111812 pub fn transfer_from_internal(1813 sender: T::AccountId,1814 from: T::AccountId,1815 recipient: T::AccountId,1816 collection: &CollectionHandle<T>,1817 item_id: TokenId,1818 amount: u128,1819 ) -> DispatchResult {1820 // Check approval1821 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, &from, &sender));18221823 // Limits check1824 Self::is_correct_transfer(&collection, &recipient)?;18251826 // Transfer permissions check1827 ensure!(1828 approval >= amount || 1829 (1830 collection.limits.owner_can_transfer &&1831 Self::is_owner_or_admin_permissions(&collection, sender.clone())1832 ),1833 Error::<T>::NoPermission1834 );18351836 if collection.access == AccessMode::WhiteList {1837 Self::check_white_list(&collection, &sender)?;1838 Self::check_white_list(&collection, &recipient)?;1839 }18401841 // Reduce approval by transferred amount or remove if remaining approval drops to 01842 if approval.saturating_sub(amount) > 0 {1843 <Allowances<T>>::insert(collection.id, (item_id, &from, &sender), approval - amount);1844 } else {1845 <Allowances<T>>::remove(collection.id, (item_id, &from, &sender));1846 }18471848 match collection.mode {1849 CollectionMode::NFT => {1850 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1851 }1852 CollectionMode::Fungible(_) => {1853 Self::transfer_fungible(&collection, amount, &from, &recipient)?1854 }1855 CollectionMode::ReFungible => {1856 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1857 }1858 _ => ()1859 };18601861 pub fn create_multiple_items_internal(1862 sender: T::CrossAccountId,1863 collection: &CollectionHandle<T>,1864 owner: T::CrossAccountId,1865 items_data: Vec<CreateItemData>,1866 ) -> DispatchResult {1867 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18681869 for data in &items_data {1870 Self::validate_create_item_args(&collection, data)?;1871 }1872 for data in &items_data {1873 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1874 }18751876 Ok(())1877 }18781879 pub fn burn_item_internal(1880 sender: &T::CrossAccountId,1881 collection: &CollectionHandle<T>,1882 item_id: TokenId,1883 value: u128,1884 ) -> DispatchResult {1885 ensure!(1886 Self::is_item_owner(sender.clone(), &collection, item_id) ||1887 (1888 collection.limits.owner_can_transfer &&1889 Self::is_owner_or_admin_permissions(&collection, sender.clone())1890 ),1891 Error::<T>::NoPermission1892 );18931894 if collection.access == AccessMode::WhiteList {1895 Self::check_white_list(&collection, &sender)?;1896 }18971898 match collection.mode1899 {1900 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1901 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1902 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1903 _ => ()1904 };19051906 Ok(())1907 }19081909 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1910 let collection_id = collection.id;19111912 // check token limit and account token limit1913 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1914 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1915 1916 Ok(())1917 }19181919 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1920 let collection_id = collection.id;19211922 // check token limit and account token limit1923 let total_items: u32 = ItemListIndex::get(collection_id)1924 .checked_add(amount)1925 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1926 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1927 .checked_add(amount)1928 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1929 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1930 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);19311932 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1933 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1934 Self::check_white_list(collection, owner)?;1935 Self::check_white_list(collection, sender)?;1936 }19371938 Ok(())1939 }19401941 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1942 match target_collection.mode1943 {1944 CollectionMode::NFT => {1945 if let CreateItemData::NFT(data) = data {1946 // check sizes1947 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1948 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1949 } else {1950 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1951 }1952 },1953 CollectionMode::Fungible(_) => {1954 if let CreateItemData::Fungible(_) = data {1955 } else {1956 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1957 }1958 },1959 CollectionMode::ReFungible => {1960 if let CreateItemData::ReFungible(data) = data {19611962 // check sizes1963 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1964 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19651966 // Check refungibility limits1967 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1968 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1969 } else {1970 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1971 }1972 },1973 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1974 };19751976 Ok(())1977 }19781979 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1980 match data1981 {1982 CreateItemData::NFT(data) => {1983 let item = NftItemType {1984 owner: owner.clone(),1985 const_data: data.const_data,1986 variable_data: data.variable_data1987 };19881989 Self::add_nft_item(collection, item)?;1990 },1991 CreateItemData::Fungible(data) => {1992 Self::add_fungible_item(collection, &owner, data.value)?;1993 },1994 CreateItemData::ReFungible(data) => {1995 let mut owner_list = Vec::new();1996 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19971998 let item = ReFungibleItemType {1999 owner: owner_list,2000 const_data: data.const_data,2001 variable_data: data.variable_data2002 };20032004 Self::add_refungible_item(collection, item)?;2005 }2006 };20072008 Ok(())2009 }20102011 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {2012 let collection_id = collection.id;20132014 // Does new owner already have an account?2015 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;20162017 // Mint 2018 let item = FungibleItemType {2019 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,2020 };2021 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);20222023 // Update balance2024 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2025 .checked_add(value)2026 .ok_or(Error::<T>::NumOverflow)?;2027 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20282029 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2030 Ok(())2031 }20322033 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {2034 let collection_id = collection.id;20352036 let current_index = <ItemListIndex>::get(collection_id)2037 .checked_add(1)2038 .ok_or(Error::<T>::NumOverflow)?;2039 let itemcopy = item.clone();20402041 ensure!(2042 item.owner.len() == 1,2043 Error::<T>::BadCreateRefungibleCall,2044 );2045 let item_owner = item.owner.first().expect("only one owner is defined");20462047 let value = item_owner.fraction;2048 let owner = item_owner.owner.clone();20492050 Self::add_token_index(collection_id, current_index, &owner)?;20512052 <ItemListIndex>::insert(collection_id, current_index);2053 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20542055 // Update balance2056 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2057 .checked_add(value)2058 .ok_or(Error::<T>::NumOverflow)?;2059 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20602061 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2062 Ok(())2063 }20642065 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2066 let collection_id = collection.id;20672068 let current_index = <ItemListIndex>::get(collection_id)2069 .checked_add(1)2070 .ok_or(Error::<T>::NumOverflow)?;20712072 let item_owner = item.owner.clone();2073 Self::add_token_index(collection_id, current_index, &item.owner)?;20742075 <ItemListIndex>::insert(collection_id, current_index);2076 <NftItemList<T>>::insert(collection_id, current_index, item);20772078 // Update balance2079 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2080 .checked_add(1)2081 .ok_or(Error::<T>::NumOverflow)?;2082 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);20832084 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2085 Ok(())2086 }20872088 fn burn_refungible_item(2089 collection: &CollectionHandle<T>,2090 item_id: TokenId,2091 owner: &T::CrossAccountId,2092 ) -> DispatchResult {2093 let collection_id = collection.id;20942095 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2096 .ok_or(Error::<T>::TokenNotFound)?;2097 let rft_balance = token2098 .owner2099 .iter()2100 .find(|&i| i.owner == *owner)2101 .ok_or(Error::<T>::TokenNotFound)?;2102 Self::remove_token_index(collection_id, item_id, owner)?;21032104 // update balance2105 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())2106 .checked_sub(rft_balance.fraction)2107 .ok_or(Error::<T>::NumOverflow)?;2108 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);21092110 // Re-create owners list with sender removed2111 let index = token2112 .owner2113 .iter()2114 .position(|i| i.owner == *owner)2115 .expect("owned item is exists");2116 token.owner.remove(index);2117 let owner_count = token.owner.len();21182119 // Burn the token completely if this was the last (only) owner2120 if owner_count == 0 {2121 <ReFungibleItemList<T>>::remove(collection_id, item_id);2122 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2123 }2124 else {2125 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2126 }21272128 Ok(())2129 }21302131 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2132 let collection_id = collection.id;21332134 let item = <NftItemList<T>>::get(collection_id, item_id)2135 .ok_or(Error::<T>::TokenNotFound)?;2136 Self::remove_token_index(collection_id, item_id, &item.owner)?;21372138 // update balance2139 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2140 .checked_sub(1)2141 .ok_or(Error::<T>::NumOverflow)?;2142 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2143 <NftItemList<T>>::remove(collection_id, item_id);2144 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21452146 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2147 Ok(())2148 }21492150 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2151 let collection_id = collection.id;21522153 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2154 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21552156 // update balance2157 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2158 .checked_sub(value)2159 .ok_or(Error::<T>::NumOverflow)?;2160 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);21612162 if balance.value - value > 0 {2163 balance.value -= value;2164 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2165 }2166 else {2167 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2168 }21692170 Ok(())2171 }21722173 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2174 Ok(<CollectionById<T>>::get(collection_id)2175 .map(|collection| CollectionHandle {2176 id: collection_id,2177 collection2178 })2179 .ok_or(Error::<T>::CollectionNotFound)?)2180 }21812182 fn save_collection(collection: CollectionHandle<T>) {2183 <CollectionById<T>>::insert(collection.id, collection.collection);2184 }21852186 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2187 ensure!(2188 subject == target_collection.owner,2189 Error::<T>::NoPermission2190 );21912192 Ok(())2193 }21942195 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2196 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2197 }21982199 fn check_owner_or_admin_permissions(2200 collection: &CollectionHandle<T>,2201 subject: T::AccountId,2202 ) -> DispatchResult {2203 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);22042205 Ok(())2206 }22072208 fn owned_amount(2209 subject: T::AccountId,2210 target_collection: &CollectionHandle<T>,2211 item_id: TokenId,2212 ) -> Option<u128> {2213 let collection_id = target_collection.id;22142215 match target_collection.mode {2216 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2217 .then(|| 1),2218 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2219 .value),2220 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2221 .owner2222 .iter()2223 .find(|i| i.owner == subject)2224 .map(|i| i.fraction),2225 CollectionMode::Invalid => None,2226 }2227 }22282229 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2230 match target_collection.mode {2231 CollectionMode::Fungible(_) => true,2232 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2233 }2234 }22352236 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2237 let collection_id = collection.id;22382239 let mes = Error::<T>::AddresNotInWhiteList;2240 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);22412242 Ok(())2243 }22442245 /// Check if token exists. In case of Fungible, check if there is an entry for 2246 /// the owner in fungible balances double map2247 fn token_exists(2248 target_collection: &CollectionHandle<T>,2249 item_id: TokenId,2250 ) -> DispatchResult {2251 let collection_id = target_collection.id;2252 let exists = match target_collection.mode2253 {2254 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2255 CollectionMode::Fungible(_) => true,2256 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2257 _ => false2258 };22592260 ensure!(exists == true, Error::<T>::TokenNotFound);2261 Ok(())2262 }22632264 fn transfer_fungible(2265 collection: &CollectionHandle<T>,2266 value: u128,2267 owner: &T::AccountId,2268 recipient: &T::AccountId,2269 ) -> DispatchResult {2270 let collection_id = collection.id;22712272 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2273 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22742275 // Send balance to recipient (updates balanceOf of recipient)2276 Self::add_fungible_item(collection, recipient, value)?;22772278 // update balanceOf of sender2279 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);22802281 // Reduce or remove sender2282 if balance.value == value {2283 <FungibleItemList<T>>::remove(collection_id, owner);2284 }2285 else {2286 balance.value -= value;2287 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2288 }22892290 Ok(())2291 }22922293 fn transfer_refungible(2294 collection: &CollectionHandle<T>,2295 item_id: TokenId,2296 value: u128,2297 owner: T::AccountId,2298 new_owner: T::AccountId,2299 ) -> DispatchResult {2300 let collection_id = collection.id;2301 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2302 .ok_or(Error::<T>::TokenNotFound)?;23032304 let item = full_item2305 .owner2306 .iter()2307 .filter(|i| i.owner == owner)2308 .next()2309 .ok_or(Error::<T>::TokenNotFound)?;2310 let amount = item.fraction;23112312 ensure!(amount >= value, Error::<T>::TokenValueTooLow);23132314 // update balance2315 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2316 .checked_sub(value)2317 .ok_or(Error::<T>::NumOverflow)?;2318 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23192320 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2321 .checked_add(value)2322 .ok_or(Error::<T>::NumOverflow)?;2323 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);23242325 let old_owner = item.owner.clone();2326 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);23272328 // transfer2329 if amount == value && !new_owner_has_account {2330 // change owner2331 // new owner do not have account2332 let mut new_full_item = full_item.clone();2333 new_full_item2334 .owner2335 .iter_mut()2336 .find(|i| i.owner == owner)2337 .expect("old owner does present in refungible")2338 .owner = new_owner.clone();2339 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23402341 // update index collection2342 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2343 } else {2344 let mut new_full_item = full_item.clone();2345 new_full_item2346 .owner2347 .iter_mut()2348 .find(|i| i.owner == owner)2349 .expect("old owner does present in refungible")2350 .fraction -= value;23512352 // separate amount2353 if new_owner_has_account {2354 // new owner has account2355 new_full_item2356 .owner2357 .iter_mut()2358 .find(|i| i.owner == new_owner)2359 .expect("new owner has account")2360 .fraction += value;2361 } else {2362 // new owner do not have account2363 new_full_item.owner.push(Ownership {2364 owner: new_owner.clone(),2365 fraction: value,2366 });2367 Self::add_token_index(collection_id, item_id, &new_owner)?;2368 }23692370 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2371 }23722373 Ok(())2374 }23752376 fn transfer_nft(2377 collection: &CollectionHandle<T>,2378 item_id: TokenId,2379 sender: T::AccountId,2380 new_owner: T::AccountId,2381 ) -> DispatchResult {2382 let collection_id = collection.id;2383 let mut item = <NftItemList<T>>::get(collection_id, item_id)2384 .ok_or(Error::<T>::TokenNotFound)?;23852386 ensure!(2387 sender == item.owner,2388 Error::<T>::MustBeTokenOwner2389 );23902391 // update balance2392 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2393 .checked_sub(1)2394 .ok_or(Error::<T>::NumOverflow)?;2395 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);23962397 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2398 .checked_add(1)2399 .ok_or(Error::<T>::NumOverflow)?;2400 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);24012402 // change owner2403 let old_owner = item.owner.clone();2404 item.owner = new_owner.clone();2405 <NftItemList<T>>::insert(collection_id, item_id, item);24062407 // update index collection2408 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;24092410 Ok(())2411 }2412 2413 fn set_re_fungible_variable_data(2414 collection: &CollectionHandle<T>,2415 item_id: TokenId,2416 data: Vec<u8>2417 ) -> DispatchResult {2418 let collection_id = collection.id;2419 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2420 .ok_or(Error::<T>::TokenNotFound)?;24212422 item.variable_data = data;24232424 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24252426 Ok(())2427 }24282429 fn set_nft_variable_data(2430 collection: &CollectionHandle<T>,2431 item_id: TokenId,2432 data: Vec<u8>2433 ) -> DispatchResult {2434 let collection_id = collection.id;2435 let mut item = <NftItemList<T>>::get(collection_id, item_id)2436 .ok_or(Error::<T>::TokenNotFound)?;2437 2438 item.variable_data = data;24392440 <NftItemList<T>>::insert(collection_id, item_id, item);2441 2442 Ok(())2443 }24442445 fn init_collection(item: &Collection<T>) {2446 // check params2447 assert!(2448 item.decimal_points <= MAX_DECIMAL_POINTS,2449 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2450 );2451 assert!(2452 item.name.len() <= 64,2453 "Collection name can not be longer than 63 char"2454 );2455 assert!(2456 item.name.len() <= 256,2457 "Collection description can not be longer than 255 char"2458 );2459 assert!(2460 item.token_prefix.len() <= 16,2461 "Token prefix can not be longer than 15 char"2462 );24632464 // Generate next collection ID2465 let next_id = CreatedCollectionCount::get()2466 .checked_add(1)2467 .unwrap();24682469 CreatedCollectionCount::put(next_id);2470 }24712472 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2473 let current_index = <ItemListIndex>::get(collection_id)2474 .checked_add(1)2475 .unwrap();24762477 let item_owner = item.owner.clone();2478 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24792480 <ItemListIndex>::insert(collection_id, current_index);24812482 // Update balance2483 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2484 .checked_add(1)2485 .unwrap();2486 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2487 }24882489 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2490 let current_index = <ItemListIndex>::get(collection_id)2491 .checked_add(1)2492 .unwrap();24932494 Self::add_token_index(collection_id, current_index, owner).unwrap();24952496 <ItemListIndex>::insert(collection_id, current_index);24972498 // Update balance2499 let new_balance = <Balance<T>>::get(collection_id, owner)2500 .checked_add(item.value)2501 .unwrap();2502 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2503 }25042505 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2506 let current_index = <ItemListIndex>::get(collection_id)2507 .checked_add(1)2508 .unwrap();25092510 let value = item.owner.first().unwrap().fraction;2511 let owner = item.owner.first().unwrap().owner.clone();25122513 Self::add_token_index(collection_id, current_index, &owner).unwrap();25142515 <ItemListIndex>::insert(collection_id, current_index);25162517 // Update balance2518 let new_balance = <Balance<T>>::get(collection_id, &owner)2519 .checked_add(value)2520 .unwrap();2521 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2522 }25232524 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2525 // add to account limit2526 if <AccountItemCount<T>>::contains_key(owner) {25272528 // bound Owned tokens by a single address2529 let count = <AccountItemCount<T>>::get(owner);2530 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25312532 <AccountItemCount<T>>::insert(owner.clone(), count2533 .checked_add(1)2534 .ok_or(Error::<T>::NumOverflow)?);2535 }2536 else {2537 <AccountItemCount<T>>::insert(owner.clone(), 1);2538 }25392540 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2541 if list_exists {2542 let mut list = <AddressTokens<T>>::get(collection_id, owner);2543 let item_contains = list.contains(&item_index.clone());25442545 if !item_contains {2546 list.push(item_index.clone());2547 }25482549 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2550 } else {2551 let mut itm = Vec::new();2552 itm.push(item_index.clone());2553 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2554 }25552556 Ok(())2557 }25582559 fn remove_token_index(2560 collection_id: CollectionId,2561 item_index: TokenId,2562 owner: &T::AccountId,2563 ) -> DispatchResult {25642565 // update counter2566 <AccountItemCount<T>>::insert(owner.clone(), 2567 <AccountItemCount<T>>::get(owner)2568 .checked_sub(1)2569 .ok_or(Error::<T>::NumOverflow)?);257025712572 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2573 if list_exists {2574 let mut list = <AddressTokens<T>>::get(collection_id, owner);2575 let item_contains = list.contains(&item_index.clone());25762577 if item_contains {2578 list.retain(|&item| item != item_index);2579 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2580 }2581 }25822583 Ok(())2584 }25852586 fn move_token_index(2587 collection_id: CollectionId,2588 item_index: TokenId,2589 old_owner: &T::AccountId,2590 new_owner: &T::AccountId,2591 ) -> DispatchResult {2592 Self::remove_token_index(collection_id, item_index, old_owner)?;2593 Self::add_token_index(collection_id, item_index, new_owner)?;25942595 Ok(())2596 }2597 2598 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2599 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);26002601 Ok(())2602 }2603}26042605////////////////////////////////////////////////////////////////////////////////////////////////////2606// Economic models2607// #region26082609/// Fee multiplier.2610pub type Multiplier = FixedU128;26112612type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;26132614/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2615/// in the queue.2616#[derive(Encode, Decode, Clone, Eq, PartialEq)]2617pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);26182619impl<T: Config + Send + Sync> sp_std::fmt::Debug 2620 for ChargeTransactionPayment<T>2621{2622 #[cfg(feature = "std")]2623 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2624 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2625 }2626 #[cfg(not(feature = "std"))]2627 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2628 Ok(())2629 }2630}26312632impl<T: Config> ChargeTransactionPayment<T>2633where2634 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2635 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2636 T::AccountId: AsRef<[u8]>,2637 T::AccountId: UncheckedFrom<T::Hash>,2638{2639 fn traditional_fee(2640 len: usize,2641 info: &DispatchInfoOf<T::Call>,2642 tip: BalanceOf<T>,2643 ) -> BalanceOf<T>2644 where2645 T::Call: Dispatchable<Info = DispatchInfo>,2646 {2647 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2648 }26492650 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2651 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2652 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2653 let len_saturation = max_block_length as u64 / (len as u64).max(1);2654 let coefficient: BalanceOf<T> = weight_saturation2655 .min(len_saturation)2656 .saturated_into::<BalanceOf<T>>();2657 final_fee2658 .saturating_mul(coefficient)2659 .saturated_into::<TransactionPriority>()2660 }26612662 fn withdraw_fee(2663 &self,2664 who: &T::AccountId,2665 call: &T::Call,2666 info: &DispatchInfoOf<T::Call>,2667 len: usize,2668 ) -> Result<2669 (2670 BalanceOf<T>,2671 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2672 ),2673 TransactionValidityError,2674 > {2675 let tip = self.0;26762677 let fee = Self::traditional_fee(len, info, tip);26782679 // Only mess with balances if fee is not zero.2680 if fee.is_zero() {2681 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2682 .map(|i| (fee, i));2683 }26842685 // Determine who is paying transaction fee based on ecnomic model2686 // Parse call to extract collection ID and access collection sponsor2687 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2688 Some(Call::create_item(collection_id, _owner, _properties)) => {2689 let collection = <CollectionById<T>>::get(collection_id)?;26902691 // sponsor timeout2692 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26932694 let limit = collection.limits.sponsor_transfer_timeout;2695 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2696 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2697 let limit_time = last_tx_block + limit.into();2698 if block_number <= limit_time {2699 return None;2700 }2701 }2702 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);27032704 // check free create limit2705 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2706 collection.sponsorship.sponsor()2707 .cloned()2708 } else {2709 None2710 }2711 }2712 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2713 let collection = <CollectionById<T>>::get(collection_id)?;2714 2715 let mut sponsor_transfer = false;2716 if collection.sponsorship.confirmed() {27172718 let collection_limits = collection.limits;2719 let collection_mode = collection.mode;2720 2721 // sponsor timeout2722 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2723 sponsor_transfer = match collection_mode {2724 CollectionMode::NFT => {2725 2726 // get correct limit2727 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2728 collection_limits.sponsor_transfer_timeout2729 } else {2730 ChainLimit::get().nft_sponsor_transfer_timeout2731 };2732 2733 let mut sponsored = true;2734 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2735 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2736 let limit_time = last_tx_block + limit.into();2737 if block_number <= limit_time {2738 sponsored = false;2739 }2740 }2741 if sponsored {2742 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2743 }27442745 sponsored2746 }2747 CollectionMode::Fungible(_) => {2748 2749 // get correct limit2750 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2751 collection_limits.sponsor_transfer_timeout2752 } else {2753 ChainLimit::get().fungible_sponsor_transfer_timeout2754 };2755 2756 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2757 let mut sponsored = true;2758 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2759 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2760 let limit_time = last_tx_block + limit.into();2761 if block_number <= limit_time {2762 sponsored = false;2763 }2764 }2765 if sponsored {2766 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2767 }27682769 sponsored2770 }2771 CollectionMode::ReFungible => {2772 2773 // get correct limit2774 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2775 collection_limits.sponsor_transfer_timeout2776 } else {2777 ChainLimit::get().refungible_sponsor_transfer_timeout2778 };2779 2780 let mut sponsored = true;2781 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2782 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2783 let limit_time = last_tx_block + limit.into();2784 if block_number <= limit_time {2785 sponsored = false;2786 }2787 }2788 if sponsored {2789 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2790 }27912792 sponsored2793 }2794 _ => {2795 false2796 },2797 };2798 }27992800 if !sponsor_transfer {2801 None2802 } else {2803 collection.sponsorship.sponsor()2804 .cloned()2805 }2806 }28072808 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2809 let mut sponsor_metadata_changes = false;28102811 let collection = <CollectionById<T>>::get(collection_id)?;28122813 if2814 collection.sponsorship.confirmed() &&2815 // Can't sponsor fungible collection, this tx will be rejected2816 // as invalid2817 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2818 data.len() <= collection.limits.sponsored_data_size as usize2819 {2820 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2821 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;28222823 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2824 .map(|last_block| block_number - last_block > rate_limit)2825 .unwrap_or(true) 2826 {2827 sponsor_metadata_changes = true;2828 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2829 }2830 }2831 }28322833 if !sponsor_metadata_changes {2834 None2835 } else {2836 collection.sponsorship.sponsor().cloned()2837 }2838 }28392840 _ => None,2841 })();28422843 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2844 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28452846 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28472848 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2849 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2850 2851 if !owned_contract && white_list_enabled {2852 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2853 return Err(InvalidTransaction::Call.into());2854 }2855 }2856 },2857 _ => {},2858 }28592860 // Sponsor smart contracts2861 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28622863 // On instantiation: set the contract owner2864 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28652866 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2867 &who,2868 code_hash,2869 salt,2870 );2871 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28722873 None2874 },28752876 // On instantiation with code: set the contract owner2877 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28782879 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2880 &who,2881 &T::Hashing::hash(&_code),2882 _salt,2883 );28842885 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28862887 None2888 }28892890 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2891 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28922893 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28942895 let mut sponsor_transfer = false;2896 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2897 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2898 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2899 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2900 let limit_time = last_tx_block + rate_limit;29012902 if block_number >= limit_time {2903 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2904 sponsor_transfer = true;2905 }2906 } else {2907 sponsor_transfer = false;2908 }2909 2910 if sponsor_transfer {2911 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2912 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2913 return Some(called_contract);2914 }2915 }2916 }29172918 None2919 },29202921 _ => None,2922 });29232924 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());29252926 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2927 .map(|i| (fee, i))2928 }2929}293029312932impl<T: Config + Send + Sync> SignedExtension2933 for ChargeTransactionPayment<T>2934where2935 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2936 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2937 T::AccountId: AsRef<[u8]>,2938 T::AccountId: UncheckedFrom<T::Hash>,2939{2940 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2941 type AccountId = T::AccountId;2942 type Call = T::Call;2943 type AdditionalSigned = ();2944 type Pre = (2945 // tip2946 BalanceOf<T>,2947 // who pays fee2948 Self::AccountId,2949 // imbalance resulting from withdrawing the fee2950 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2951 );2952 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2953 Ok(())2954 }29552956 fn validate(2957 &self,2958 who: &Self::AccountId,2959 call: &Self::Call,2960 info: &DispatchInfoOf<Self::Call>,2961 len: usize,2962 ) -> TransactionValidity {2963 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2964 Ok(ValidTransaction {2965 priority: Self::get_priority(len, info, fee),2966 ..Default::default()2967 })2968 }29692970 fn pre_dispatch(2971 self,2972 who: &Self::AccountId,2973 call: &Self::Call,2974 info: &DispatchInfoOf<Self::Call>,2975 len: usize,2976 ) -> Result<Self::Pre, TransactionValidityError> {2977 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2978 Ok((self.0, who.clone(), imbalance))2979 }29802981 fn post_dispatch(2982 pre: Self::Pre,2983 info: &DispatchInfoOf<Self::Call>,2984 post_info: &PostDispatchInfoOf<Self::Call>,2985 len: usize,2986 _result: &DispatchResult,2987 ) -> Result<(), TransactionValidityError> {2988 let (tip, who, imbalance) = pre;2989 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2990 len as u32,2991 info,2992 post_info,2993 tip,2994 );2995 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2996 Ok(())2997 }2998}29993000// #endregion30013002sp_api::decl_runtime_apis! {3003 pub trait NftApi {3004 /// Used for ethereum integration3005 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;3006 }3007}