difftreelog
feat burn_from
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"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 CUSTOM_DATA_LIMIT, COLLECTION_NUMBER_LIMIT, ACCOUNT_TOKEN_OWNERSHIP_LIMIT,42 VARIABLE_ON_CHAIN_SCHEMA_LIMIT, CONST_ON_CHAIN_SCHEMA_LIMIT, COLLECTION_ADMINS_LIMIT,43 OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,44 MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,45 CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,46 MetaUpdatePermission, FungibleItemType, ReFungibleItemType,47};4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;58pub use eth::sponsoring::NftEthSponsorshipHandler;5960pub use eth::NftErcSupport;61pub use eth::account::*;62use eth::erc::{ERC20Events, ERC721Events};6364#[cfg(feature = "runtime-benchmarks")]65mod benchmarking;66pub mod weights;67use weights::WeightInfo;6869decl_error! {70 /// Error for non-fungible-token module.71 pub enum Error for Module<T: Config> {72 /// Total collections bound exceeded.73 TotalCollectionsLimitExceeded,74 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.75 CollectionDecimalPointLimitExceeded,76 /// Collection name can not be longer than 63 char.77 CollectionNameLimitExceeded,78 /// Collection description can not be longer than 255 char.79 CollectionDescriptionLimitExceeded,80 /// Token prefix can not be longer than 15 char.81 CollectionTokenPrefixLimitExceeded,82 /// This collection does not exist.83 CollectionNotFound,84 /// Item not exists.85 TokenNotFound,86 /// Admin not found87 AdminNotFound,88 /// Arithmetic calculation overflow.89 NumOverflow,90 /// Account already has admin role.91 AlreadyAdmin,92 /// You do not own this collection.93 NoPermission,94 /// This address is not set as sponsor, use setCollectionSponsor first.95 ConfirmUnsetSponsorFail,96 /// Collection is not in mint mode.97 PublicMintingNotAllowed,98 /// Sender parameter and item owner must be equal.99 MustBeTokenOwner,100 /// Item balance not enough.101 TokenValueTooLow,102 /// Size of item is too large.103 NftSizeLimitExceeded,104 /// No approve found105 ApproveNotFound,106 /// Requested value more than approved.107 TokenValueNotEnough,108 /// Only approved addresses can call this method.109 ApproveRequired,110 /// Address is not in white list.111 AddresNotInWhiteList,112 /// Number of collection admins bound exceeded.113 CollectionAdminsLimitExceeded,114 /// Owned tokens by a single address bound exceeded.115 AddressOwnershipLimitExceeded,116 /// Length of items properties must be greater than 0.117 EmptyArgument,118 /// const_data exceeded data limit.119 TokenConstDataLimitExceeded,120 /// variable_data exceeded data limit.121 TokenVariableDataLimitExceeded,122 /// Not NFT item data used to mint in NFT collection.123 NotNftDataUsedToMintNftCollectionToken,124 /// Not Fungible item data used to mint in Fungible collection.125 NotFungibleDataUsedToMintFungibleCollectionToken,126 /// Not Re Fungible item data used to mint in Re Fungible collection.127 NotReFungibleDataUsedToMintReFungibleCollectionToken,128 /// Unexpected collection type.129 UnexpectedCollectionType,130 /// Can't store metadata in fungible tokens.131 CantStoreMetadataInFungibleTokens,132 /// Collection token limit exceeded133 CollectionTokenLimitExceeded,134 /// Account token limit exceeded per collection135 AccountTokenLimitExceeded,136 /// Collection limit bounds per collection exceeded137 CollectionLimitBoundsExceeded,138 /// Tried to enable permissions which are only permitted to be disabled139 OwnerPermissionsCantBeReverted,140 /// Schema data size limit bound exceeded141 SchemaDataLimitExceeded,142 /// Maximum refungibility exceeded143 WrongRefungiblePieces,144 /// createRefungible should be called with one owner145 BadCreateRefungibleCall,146 /// Gas limit exceeded147 OutOfGas,148 /// Metadata update denied by collection settings149 MetadataUpdateDenied,150 /// Metadata update flag become unmutable with None option151 MetadataFlagFrozen,152 /// Collection settings not allowing items transferring153 TransferNotAllowed,154 /// Can't transfer tokens to ethereum zero address155 AddressIsZero,156 }157}158159#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]160pub struct CollectionHandle<T: Config> {161 pub id: CollectionId,162 collection: Collection<T>,163 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,164}165impl<T: Config> CollectionHandle<T> {166 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {167 <CollectionById<T>>::get(id).map(|collection| Self {168 id,169 collection,170 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(171 eth::collection_id_to_address(id),172 gas_limit,173 ),174 })175 }176 pub fn get(id: CollectionId) -> Option<Self> {177 Self::get_with_gas_limit(id, u64::MAX)178 }179 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {180 self.recorder.log_sub(log)181 }182 #[allow(dead_code)]183 fn consume_gas(&self, gas: u64) -> DispatchResult {184 self.recorder.consume_gas_sub(gas)185 }186 fn consume_sload(&self) -> DispatchResult {187 self.recorder.consume_sload_sub()188 }189 fn consume_sstore(&self) -> DispatchResult {190 self.recorder.consume_sstore_sub()191 }192 pub fn submit_logs(self) -> DispatchResult {193 self.recorder.submit_logs()194 }195 pub fn save(self) -> DispatchResult {196 self.recorder.submit_logs()?;197 <CollectionById<T>>::insert(self.id, self.collection);198 Ok(())199 }200}201impl<T: Config> Deref for CollectionHandle<T> {202 type Target = Collection<T>;203204 fn deref(&self) -> &Self::Target {205 &self.collection206 }207}208209impl<T: Config> DerefMut for CollectionHandle<T> {210 fn deref_mut(&mut self) -> &mut Self::Target {211 &mut self.collection212 }213}214215pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {216 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;217218 /// Weight information for extrinsics in this pallet.219 type WeightInfo: WeightInfo;220221 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;222 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;223224 type CrossAccountId: CrossAccountId<Self::AccountId>;225 type Currency: Currency<Self::AccountId>;226 type CollectionCreationPrice: Get<227 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,228 >;229 type TreasuryAccountId: Get<Self::AccountId>;230}231232type SelfWeightOf<T> = <T as Config>::WeightInfo;233234trait WeightInfoHelpers: WeightInfo {235 fn transfer() -> Weight {236 Self::transfer_nft()237 .max(Self::transfer_fungible())238 .max(Self::transfer_refungible())239 }240 fn transfer_from() -> Weight {241 Self::transfer_from_nft()242 .max(Self::transfer_from_fungible())243 .max(Self::transfer_from_refungible())244 }245 fn approve() -> Weight {246 // TODO: refungible, fungible247 Self::approve_nft()248 }249 fn set_variable_meta_data(data: u32) -> Weight {250 // TODO: refungible251 Self::set_variable_meta_data_nft(data)252 }253 fn create_item(data: u32) -> Weight {254 Self::create_item_nft(data)255 .max(Self::create_item_fungible())256 .max(Self::create_item_refungible(data))257 }258 fn create_multiple_items(amount: u32) -> Weight {259 Self::create_multiple_items_nft(amount)260 .max(Self::create_multiple_items_fungible(amount))261 .max(Self::create_multiple_items_refungible(amount))262 }263 fn burn_item() -> Weight {264 // TODO: refungible, fungible265 Self::burn_item_nft()266 }267}268impl<T: WeightInfo> WeightInfoHelpers for T {}269270// # Used definitions271//272// ## User control levels273//274// chain-controlled - key is uncontrolled by user275// i.e autoincrementing index276// can use non-cryptographic hash277// real - key is controlled by user278// but it is hard to generate enough colliding values, i.e owner of signed txs279// can use non-cryptographic hash280// controlled - key is completly controlled by users281// i.e maps with mutable keys282// should use cryptographic hash283//284// ## User control level downgrade reasons285//286// ?1 - chain-controlled -> controlled287// collections/tokens can be destroyed, resulting in massive holes288// ?2 - chain-controlled -> controlled289// same as ?1, but can be only added, resulting in easier exploitation290// ?3 - real -> controlled291// no confirmation required, so addresses can be easily generated292decl_storage! {293 trait Store for Module<T: Config> as Nft {294295 //#region Private members296 /// Id of next collection297 CreatedCollectionCount: u32;298 /// Used for migrations299 ChainVersion: u64;300 /// Id of last collection token301 /// Collection id (controlled?1)302 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;303 //#endregion304305 //#region Bound counters306 /// Amount of collections destroyed, used for total amount tracking with307 /// CreatedCollectionCount308 DestroyedCollectionCount: u32;309 //#endregion310311 //#region Basic collections312 /// Collection info313 /// Collection id (controlled?1)314 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;315 /// List of collection admins316 /// Collection id (controlled?2)317 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;318 /// Whitelisted collection users319 /// Collection id (controlled?2), user id (controlled?3)320 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;321 //#endregion322323 /// How many of collection items user have324 /// Collection id (controlled?2), account id (real)325 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;326327 /// Amount of items which spender can transfer out of owners account (via transferFrom)328 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))329 /// TODO: Off chain worker should remove from this map when token gets removed330 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;331332 //#region Item collections333 /// Collection id (controlled?2), token id (controlled?1)334 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;335 /// Collection id (controlled?2), owner (controlled?2)336 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;337 /// Collection id (controlled?2), token id (controlled?1)338 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;339 //#endregion340341 //#region Index list342 /// Collection id (controlled?2), tokens owner (controlled?2)343 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;344 //#endregion345346 //#region Tokens transfer rate limit baskets347 /// (Collection id (controlled?2), who created (real))348 /// TODO: Off chain worker should remove from this map when collection gets removed349 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;350 /// Collection id (controlled?2), token id (controlled?2)351 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;352 /// Collection id (controlled?2), owning user (real)353 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;354 /// Collection id (controlled?2), token id (controlled?2)355 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;356 //#endregion357358 /// Variable metadata sponsoring359 /// Collection id (controlled?2), token id (controlled?2)360 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;361 }362 add_extra_genesis {363 build(|config: &GenesisConfig<T>| {364 // Modification of storage365 for (_num, _c) in &config.collection_id {366 <Module<T>>::init_collection(_c);367 }368369 for (_num, _c, _i) in &config.nft_item_id {370 <Module<T>>::init_nft_token(*_c, _i);371 }372373 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375 }376377 for (_num, _c, _i) in &config.refungible_item_id {378 <Module<T>>::init_refungible_token(*_c, _i);379 }380 })381 }382}383384decl_event!(385 pub enum Event<T>386 where387 AccountId = <T as frame_system::Config>::AccountId,388 CrossAccountId = <T as Config>::CrossAccountId,389 {390 /// New collection was created391 ///392 /// # Arguments393 ///394 /// * collection_id: Globally unique identifier of newly created collection.395 ///396 /// * mode: [CollectionMode] converted into u8.397 ///398 /// * account_id: Collection owner.399 CollectionCreated(CollectionId, u8, AccountId),400401 /// New item was created.402 ///403 /// # Arguments404 ///405 /// * collection_id: Id of the collection where item was created.406 ///407 /// * item_id: Id of an item. Unique within the collection.408 ///409 /// * recipient: Owner of newly created item410 ItemCreated(CollectionId, TokenId, CrossAccountId),411412 /// Collection item was burned.413 ///414 /// # Arguments415 ///416 /// collection_id.417 ///418 /// item_id: Identifier of burned NFT.419 ItemDestroyed(CollectionId, TokenId),420421 /// Item was transferred422 ///423 /// * collection_id: Id of collection to which item is belong424 ///425 /// * item_id: Id of an item426 ///427 /// * sender: Original owner of item428 ///429 /// * recipient: New owner of item430 ///431 /// * amount: Always 1 for NFT432 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434 /// * collection_id435 ///436 /// * item_id437 ///438 /// * sender439 ///440 /// * spender441 ///442 /// * amount443 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444 }445);446447decl_module! {448 pub struct Module<T: Config> for enum Call449 where450 origin: T::Origin451 {452 fn deposit_event() = default;453 const CollectionAdminsLimit: u64 = COLLECTION_ADMINS_LIMIT;454 type Error = Error<T>;455456 fn on_initialize(_now: T::BlockNumber) -> Weight {457 0458 }459460 /// 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.461 ///462 /// # Permissions463 ///464 /// * Anyone.465 ///466 /// # Arguments467 ///468 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.469 ///470 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.471 ///472 /// * token_prefix: UTF-8 string with token prefix.473 ///474 /// * mode: [CollectionMode] collection type and type dependent data.475 // returns collection ID476 #[weight = <SelfWeightOf<T>>::create_collection()]477 #[transactional]478 pub fn create_collection(origin,479 collection_name: Vec<u16>,480 collection_description: Vec<u16>,481 token_prefix: Vec<u8>,482 mode: CollectionMode) -> DispatchResult {483484 // Anyone can create a collection485 let who = ensure_signed(origin)?;486487 // Take a (non-refundable) deposit of collection creation488 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();489 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(490 &T::TreasuryAccountId::get(),491 T::CollectionCreationPrice::get(),492 ));493 <T as Config>::Currency::settle(494 &who,495 imbalance,496 WithdrawReasons::TRANSFER,497 ExistenceRequirement::KeepAlive,498 ).map_err(|_| Error::<T>::NoPermission)?;499500 let decimal_points = match mode {501 CollectionMode::Fungible(points) => points,502 _ => 0503 };504505 let created_count = CreatedCollectionCount::get();506 let destroyed_count = DestroyedCollectionCount::get();507508 // bound Total number of collections509 ensure!(created_count - destroyed_count < COLLECTION_NUMBER_LIMIT, Error::<T>::TotalCollectionsLimitExceeded);510511 // check params512 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);513 ensure!(collection_name.len() <= MAX_COLLECTION_NAME_LENGTH, Error::<T>::CollectionNameLimitExceeded);514 ensure!(collection_description.len() <= MAX_COLLECTION_DESCRIPTION_LENGTH, Error::<T>::CollectionDescriptionLimitExceeded);515 ensure!(token_prefix.len() <= MAX_TOKEN_PREFIX_LENGTH, Error::<T>::CollectionTokenPrefixLimitExceeded);516517 // Generate next collection ID518 let next_id = created_count519 .checked_add(1)520 .ok_or(Error::<T>::NumOverflow)?;521522 CreatedCollectionCount::put(next_id);523524 let limits = CollectionLimits {525 sponsored_data_size: CUSTOM_DATA_LIMIT,526 ..Default::default()527 };528529 // Create new collection530 let new_collection = Collection {531 owner: who.clone(),532 name: collection_name,533 mode: mode.clone(),534 mint_mode: false,535 access: AccessMode::Normal,536 description: collection_description,537 decimal_points,538 token_prefix,539 offchain_schema: Vec::new(),540 schema_version: SchemaVersion::ImageURL,541 sponsorship: SponsorshipState::Disabled,542 variable_on_chain_schema: Vec::new(),543 const_on_chain_schema: Vec::new(),544 limits,545 meta_update_permission: MetaUpdatePermission::default(),546 transfers_enabled: true,547 };548549 // Add new collection to map550 <CollectionById<T>>::insert(next_id, new_collection);551552 // call event553 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));554555 Ok(())556 }557558 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.559 ///560 /// # Permissions561 ///562 /// * Collection Owner.563 ///564 /// # Arguments565 ///566 /// * collection_id: collection to destroy.567 #[weight = <SelfWeightOf<T>>::destroy_collection()]568 #[transactional]569 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {570571 let sender = ensure_signed(origin)?;572 let collection = Self::get_collection(collection_id)?;573 Self::check_owner_permissions(&collection, &sender)?;574 if !collection.limits.owner_can_destroy {575 fail!(Error::<T>::NoPermission);576 }577578 <AddressTokens<T>>::remove_prefix(collection_id, None);579 <Allowances<T>>::remove_prefix(collection_id, None);580 <Balance<T>>::remove_prefix(collection_id, None);581 <ItemListIndex>::remove(collection_id);582 <AdminList<T>>::remove(collection_id);583 <CollectionById<T>>::remove(collection_id);584 <WhiteList<T>>::remove_prefix(collection_id, None);585586 <NftItemList<T>>::remove_prefix(collection_id, None);587 <FungibleItemList<T>>::remove_prefix(collection_id, None);588 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);589590 <NftTransferBasket<T>>::remove_prefix(collection_id, None);591 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);592 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);593594 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);595596 DestroyedCollectionCount::put(DestroyedCollectionCount::get()597 .checked_add(1)598 .ok_or(Error::<T>::NumOverflow)?);599600 Ok(())601 }602603 /// Add an address to white list.604 ///605 /// # Permissions606 ///607 /// * Collection Owner608 /// * Collection Admin609 ///610 /// # Arguments611 ///612 /// * collection_id.613 ///614 /// * address.615 #[weight = <SelfWeightOf<T>>::add_to_white_list()]616 #[transactional]617 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{618619 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);620 let collection = Self::get_collection(collection_id)?;621622 Self::toggle_white_list_internal(623 &sender,624 &collection,625 &address,626 true,627 )?;628629 Ok(())630 }631632 /// Remove an address from white list.633 ///634 /// # Permissions635 ///636 /// * Collection Owner637 /// * Collection Admin638 ///639 /// # Arguments640 ///641 /// * collection_id.642 ///643 /// * address.644 #[weight = <SelfWeightOf<T>>::remove_from_white_list()]645 #[transactional]646 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{647648 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);649 let collection = Self::get_collection(collection_id)?;650651 Self::toggle_white_list_internal(652 &sender,653 &collection,654 &address,655 false,656 )?;657658 Ok(())659 }660661 /// Toggle between normal and white list access for the methods with access for `Anyone`.662 ///663 /// # Permissions664 ///665 /// * Collection Owner.666 ///667 /// # Arguments668 ///669 /// * collection_id.670 ///671 /// * mode: [AccessMode]672 #[weight = <SelfWeightOf<T>>::set_public_access_mode()]673 #[transactional]674 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult675 {676 let sender = ensure_signed(origin)?;677678 let mut target_collection = Self::get_collection(collection_id)?;679 Self::check_owner_permissions(&target_collection, &sender)?;680 target_collection.access = mode;681 target_collection.save()682 }683684 /// Allows Anyone to create tokens if:685 /// * White List is enabled, and686 /// * Address is added to white list, and687 /// * This method was called with True parameter688 ///689 /// # Permissions690 /// * Collection Owner691 ///692 /// # Arguments693 ///694 /// * collection_id.695 ///696 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.697 #[weight = <SelfWeightOf<T>>::set_mint_permission()]698 #[transactional]699 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult700 {701 let sender = ensure_signed(origin)?;702703 let mut target_collection = Self::get_collection(collection_id)?;704 Self::check_owner_permissions(&target_collection, &sender)?;705 target_collection.mint_mode = mint_permission;706 target_collection.save()707 }708709 /// Change the owner of the collection.710 ///711 /// # Permissions712 ///713 /// * Collection Owner.714 ///715 /// # Arguments716 ///717 /// * collection_id.718 ///719 /// * new_owner.720 #[weight = <SelfWeightOf<T>>::change_collection_owner()]721 #[transactional]722 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {723724 let sender = ensure_signed(origin)?;725 let mut target_collection = Self::get_collection(collection_id)?;726 Self::check_owner_permissions(&target_collection, &sender)?;727 target_collection.owner = new_owner;728 target_collection.save()729 }730731 /// Adds an admin of the Collection.732 /// 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.733 ///734 /// # Permissions735 ///736 /// * Collection Owner.737 /// * Collection Admin.738 ///739 /// # Arguments740 ///741 /// * collection_id: ID of the Collection to add admin for.742 ///743 /// * new_admin_id: Address of new admin to add.744 #[weight = <SelfWeightOf<T>>::add_collection_admin()]745 #[transactional]746 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {747 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);748 let collection = Self::get_collection(collection_id)?;749 Self::check_owner_or_admin_permissions(&collection, &sender)?;750 let mut admin_arr = <AdminList<T>>::get(collection_id);751752 match admin_arr.binary_search(&new_admin_id) {753 Ok(_) => {},754 Err(idx) => {755 ensure!(admin_arr.len() < COLLECTION_ADMINS_LIMIT as usize, Error::<T>::CollectionAdminsLimitExceeded);756 admin_arr.insert(idx, new_admin_id);757 <AdminList<T>>::insert(collection_id, admin_arr);758 }759 }760 Ok(())761 }762763 /// 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.764 ///765 /// # Permissions766 ///767 /// * Collection Owner.768 /// * Collection Admin.769 ///770 /// # Arguments771 ///772 /// * collection_id: ID of the Collection to remove admin for.773 ///774 /// * account_id: Address of admin to remove.775 #[weight = <SelfWeightOf<T>>::remove_collection_admin()]776 #[transactional]777 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {778 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);779 let collection = Self::get_collection(collection_id)?;780 Self::check_owner_or_admin_permissions(&collection, &sender)?;781 let mut admin_arr = <AdminList<T>>::get(collection_id);782783 if let Ok(idx) = admin_arr.binary_search(&account_id) {784 admin_arr.remove(idx);785 <AdminList<T>>::insert(collection_id, admin_arr);786 }787 Ok(())788 }789790 /// # Permissions791 ///792 /// * Collection Owner793 ///794 /// # Arguments795 ///796 /// * collection_id.797 ///798 /// * new_sponsor.799 #[weight = <SelfWeightOf<T>>::set_collection_sponsor()]800 #[transactional]801 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {802 let sender = ensure_signed(origin)?;803 let mut target_collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&target_collection, &sender)?;805806 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);807 target_collection.save()808 }809810 /// # Permissions811 ///812 /// * Sponsor.813 ///814 /// # Arguments815 ///816 /// * collection_id.817 #[weight = <SelfWeightOf<T>>::confirm_sponsorship()]818 #[transactional]819 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {820 let sender = ensure_signed(origin)?;821822 let mut target_collection = Self::get_collection(collection_id)?;823 ensure!(824 target_collection.sponsorship.pending_sponsor() == Some(&sender),825 Error::<T>::ConfirmUnsetSponsorFail826 );827828 target_collection.sponsorship = SponsorshipState::Confirmed(sender);829 target_collection.save()830 }831832 /// Switch back to pay-per-own-transaction model.833 ///834 /// # Permissions835 ///836 /// * Collection owner.837 ///838 /// # Arguments839 ///840 /// * collection_id.841 #[weight = <SelfWeightOf<T>>::remove_collection_sponsor()]842 #[transactional]843 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844 let sender = ensure_signed(origin)?;845846 let mut target_collection = Self::get_collection(collection_id)?;847 Self::check_owner_permissions(&target_collection, &sender)?;848849 target_collection.sponsorship = SponsorshipState::Disabled;850 target_collection.save()851 }852853 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.854 ///855 /// # Permissions856 ///857 /// * Collection Owner.858 /// * Collection Admin.859 /// * Anyone if860 /// * White List is enabled, and861 /// * Address is added to white list, and862 /// * MintPermission is enabled (see SetMintPermission method)863 ///864 /// # Arguments865 ///866 /// * collection_id: ID of the collection.867 ///868 /// * owner: Address, initial owner of the NFT.869 ///870 /// * data: Token data to store on chain.871 // #[weight =872 // (130_000_000 as Weight)873 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))875 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877 #[weight = <SelfWeightOf<T>>::create_item(data.data_size() as u32)]878 #[transactional]879 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881 let collection = Self::get_collection(collection_id)?;882883 Self::create_item_internal(&sender, &collection, &owner, data)?;884885 collection.submit_logs()886 }887888 /// This method creates multiple items in a collection created with CreateCollection method.889 ///890 /// # Permissions891 ///892 /// * Collection Owner.893 /// * Collection Admin.894 /// * Anyone if895 /// * White List is enabled, and896 /// * Address is added to white list, and897 /// * MintPermission is enabled (see SetMintPermission method)898 ///899 /// # Arguments900 ///901 /// * collection_id: ID of the collection.902 ///903 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].904 ///905 /// * owner: Address, initial owner of the NFT.906 #[weight = <SelfWeightOf<T>>::create_multiple_items(items_data.len() as u32)]907 #[transactional]908 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {909910 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);911 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);912 let collection = Self::get_collection(collection_id)?;913914 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;915916 collection.submit_logs()917 }918919 // TODO! transaction weight920921 /// Set transfers_enabled value for particular collection922 ///923 /// # Permissions924 ///925 /// * Collection Owner.926 ///927 /// # Arguments928 ///929 /// * collection_id: ID of the collection.930 ///931 /// * value: New flag value.932 #[weight = <SelfWeightOf<T>>::set_transfers_enabled_flag()]933 #[transactional]934 pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {935936 let sender = ensure_signed(origin)?;937 let mut target_collection = Self::get_collection(collection_id)?;938939 Self::check_owner_permissions(&target_collection, &sender)?;940941 target_collection.transfers_enabled = value;942 target_collection.save()943 }944945 // TODO! transaction weight946 /// Set meta_update_permission value for particular collection947 ///948 /// # Permissions949 ///950 /// * Collection Owner.951 ///952 /// # Arguments953 ///954 /// * collection_id: ID of the collection.955 ///956 /// * value: New flag value.957 #[weight = <T as Config>::WeightInfo::burn_item()]958 #[transactional]959 pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {960961 let sender = ensure_signed(origin)?;962 let mut target_collection = Self::get_collection(collection_id)?;963964 ensure!(965 target_collection.meta_update_permission != MetaUpdatePermission::None,966 Error::<T>::MetadataFlagFrozen967 );968 Self::check_owner_permissions(&target_collection, &sender)?;969970 target_collection.meta_update_permission = value;971972 target_collection.save()973 }974975 /// Destroys a concrete instance of NFT.976 ///977 /// # Permissions978 ///979 /// * Collection Owner.980 /// * Collection Admin.981 /// * Current NFT Owner.982 ///983 /// # Arguments984 ///985 /// * collection_id: ID of the collection.986 ///987 /// * item_id: ID of NFT to burn.988 #[weight = <SelfWeightOf<T>>::burn_item()]989 #[transactional]990 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, item_owner: T::CrossAccountId, value: u128) -> DispatchResult {991992 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);993 let target_collection = Self::get_collection(collection_id)?;994995 Self::burn_item_internal(&sender, &target_collection, item_id, &item_owner, value)?;996997 target_collection.submit_logs()998 }9991000 /// Change ownership of the token.1001 ///1002 /// # Permissions1003 ///1004 /// * Collection Owner1005 /// * Collection Admin1006 /// * Current NFT owner1007 ///1008 /// # Arguments1009 ///1010 /// * recipient: Address of token recipient.1011 ///1012 /// * collection_id.1013 ///1014 /// * item_id: ID of the item1015 /// * Non-Fungible Mode: Required.1016 /// * Fungible Mode: Ignored.1017 /// * Re-Fungible Mode: Required.1018 ///1019 /// * value: Amount to transfer.1020 /// * Non-Fungible Mode: Ignored1021 /// * Fungible Mode: Must specify transferred amount1022 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1023 #[weight = <SelfWeightOf<T>>::transfer()]1024 #[transactional]1025 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1026 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1027 let collection = Self::get_collection(collection_id)?;10281029 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;10301031 collection.submit_logs()1032 }10331034 /// Set, change, or remove approved address to transfer the ownership of the NFT.1035 ///1036 /// # Permissions1037 ///1038 /// * Collection Owner1039 /// * Collection Admin1040 /// * Current NFT owner1041 ///1042 /// # Arguments1043 ///1044 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1045 ///1046 /// * collection_id.1047 ///1048 /// * item_id: ID of the item.1049 #[weight = <SelfWeightOf<T>>::approve()]1050 #[transactional]1051 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1052 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1053 let collection = Self::get_collection(collection_id)?;10541055 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10561057 collection.submit_logs()1058 }10591060 /// 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.1061 ///1062 /// # Permissions1063 /// * Collection Owner1064 /// * Collection Admin1065 /// * Current NFT owner1066 /// * Address approved by current NFT owner1067 ///1068 /// # Arguments1069 ///1070 /// * from: Address that owns token.1071 ///1072 /// * recipient: Address of token recipient.1073 ///1074 /// * collection_id.1075 ///1076 /// * item_id: ID of the item.1077 ///1078 /// * value: Amount to transfer.1079 #[weight = <SelfWeightOf<T>>::transfer_from()]1080 #[transactional]1081 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1082 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1083 let collection = Self::get_collection(collection_id)?;10841085 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10861087 collection.submit_logs()1088 }1089 // #[weight = 0]1090 // // let no_perm_mes = "You do not have permissions to modify this collection";1091 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1092 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1093 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10941095 // // // on_nft_received call10961097 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10981099 // Ok(())1100 // }11011102 /// Set off-chain data schema.1103 ///1104 /// # Permissions1105 ///1106 /// * Collection Owner1107 /// * Collection Admin1108 ///1109 /// # Arguments1110 ///1111 /// * collection_id.1112 ///1113 /// * schema: String representing the offchain data schema.1114 #[weight = <SelfWeightOf<T>>::set_variable_meta_data(data.len() as u32)]1115 #[transactional]1116 pub fn set_variable_meta_data (1117 origin,1118 collection_id: CollectionId,1119 item_id: TokenId,1120 data: Vec<u8>1121 ) -> DispatchResult {1122 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11231124 let collection = Self::get_collection(collection_id)?;1125 Self::meta_update_check(&sender, &collection, item_id)?;11261127 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;11281129 Ok(())1130 }11311132 /// Set schema standard1133 /// ImageURL1134 /// Unique1135 ///1136 /// # Permissions1137 ///1138 /// * Collection Owner1139 /// * Collection Admin1140 ///1141 /// # Arguments1142 ///1143 /// * collection_id.1144 ///1145 /// * schema: SchemaVersion: enum1146 #[weight = <SelfWeightOf<T>>::set_schema_version()]1147 #[transactional]1148 pub fn set_schema_version(1149 origin,1150 collection_id: CollectionId,1151 version: SchemaVersion1152 ) -> DispatchResult {1153 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1154 let mut target_collection = Self::get_collection(collection_id)?;1155 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1156 target_collection.schema_version = version;1157 target_collection.save()1158 }11591160 /// Set off-chain data schema.1161 ///1162 /// # Permissions1163 ///1164 /// * Collection Owner1165 /// * Collection Admin1166 ///1167 /// # Arguments1168 ///1169 /// * collection_id.1170 ///1171 /// * schema: String representing the offchain data schema.1172 #[weight = <SelfWeightOf<T>>::set_offchain_schema(schema.len() as u32)]1173 #[transactional]1174 pub fn set_offchain_schema(1175 origin,1176 collection_id: CollectionId,1177 schema: Vec<u8>1178 ) -> DispatchResult {1179 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180 let mut target_collection = Self::get_collection(collection_id)?;1181 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183 // check schema limit1184 ensure!(schema.len() as u32 <= OFFCHAIN_SCHEMA_LIMIT, "");11851186 target_collection.offchain_schema = schema;1187 target_collection.save()1188 }11891190 /// Set const on-chain data schema.1191 ///1192 /// # Permissions1193 ///1194 /// * Collection Owner1195 /// * Collection Admin1196 ///1197 /// # Arguments1198 ///1199 /// * collection_id.1200 ///1201 /// * schema: String representing the const on-chain data schema.1202 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1203 #[transactional]1204 pub fn set_const_on_chain_schema (1205 origin,1206 collection_id: CollectionId,1207 schema: Vec<u8>1208 ) -> DispatchResult {1209 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210 let mut target_collection = Self::get_collection(collection_id)?;1211 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12121213 // check schema limit1214 ensure!(schema.len() as u32 <= CONST_ON_CHAIN_SCHEMA_LIMIT, "");12151216 target_collection.const_on_chain_schema = schema;1217 target_collection.save()1218 }12191220 /// Set variable on-chain data schema.1221 ///1222 /// # Permissions1223 ///1224 /// * Collection Owner1225 /// * Collection Admin1226 ///1227 /// # Arguments1228 ///1229 /// * collection_id.1230 ///1231 /// * schema: String representing the variable on-chain data schema.1232 #[weight = <SelfWeightOf<T>>::set_const_on_chain_schema(schema.len() as u32)]1233 #[transactional]1234 pub fn set_variable_on_chain_schema (1235 origin,1236 collection_id: CollectionId,1237 schema: Vec<u8>1238 ) -> DispatchResult {1239 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1240 let mut target_collection = Self::get_collection(collection_id)?;1241 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12421243 // check schema limit1244 ensure!(schema.len() as u32 <= VARIABLE_ON_CHAIN_SCHEMA_LIMIT, "");12451246 target_collection.variable_on_chain_schema = schema;1247 target_collection.save()1248 }12491250 #[weight = <SelfWeightOf<T>>::set_collection_limits()]1251 #[transactional]1252 pub fn set_collection_limits(1253 origin,1254 collection_id: u32,1255 new_limits: CollectionLimits<T::BlockNumber>,1256 ) -> DispatchResult {1257 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1258 let mut target_collection = Self::get_collection(collection_id)?;1259 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1260 let old_limits = &target_collection.limits;12611262 // collection bounds1263 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1264 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1265 new_limits.sponsored_data_size <= CUSTOM_DATA_LIMIT,1266 Error::<T>::CollectionLimitBoundsExceeded);12671268 // token_limit check prev1269 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1270 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12711272 ensure!(1273 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1274 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1275 Error::<T>::OwnerPermissionsCantBeReverted,1276 );12771278 target_collection.limits = new_limits;12791280 target_collection.save()1281 }1282 }1283}12841285impl<T: Config> Module<T> {1286 pub fn create_item_internal(1287 sender: &T::CrossAccountId,1288 collection: &CollectionHandle<T>,1289 owner: &T::CrossAccountId,1290 data: CreateItemData,1291 ) -> DispatchResult {1292 ensure!(1293 owner != &T::CrossAccountId::from_eth(H160([0; 20])),1294 Error::<T>::AddressIsZero1295 );12961297 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1298 Self::validate_create_item_args(collection, &data)?;1299 Self::create_item_no_validation(collection, owner, data)?;13001301 Ok(())1302 }13031304 pub fn transfer_internal(1305 sender: &T::CrossAccountId,1306 recipient: &T::CrossAccountId,1307 target_collection: &CollectionHandle<T>,1308 item_id: TokenId,1309 value: u128,1310 ) -> DispatchResult {1311 ensure!(1312 recipient != &T::CrossAccountId::from_eth(H160([0; 20])),1313 Error::<T>::AddressIsZero1314 );13151316 // Limits check1317 Self::is_correct_transfer(target_collection, recipient)?;13181319 // Transfer permissions check1320 ensure!(1321 Self::is_item_owner(sender, target_collection, item_id)?1322 || Self::is_owner_or_admin_permissions(target_collection, sender)?,1323 Error::<T>::NoPermission1324 );13251326 if target_collection.access == AccessMode::WhiteList {1327 Self::check_white_list(target_collection, sender)?;1328 Self::check_white_list(target_collection, recipient)?;1329 }13301331 match target_collection.mode {1332 CollectionMode::NFT => Self::transfer_nft(1333 target_collection,1334 item_id,1335 sender.clone(),1336 recipient.clone(),1337 )?,1338 CollectionMode::Fungible(_) => {1339 Self::transfer_fungible(target_collection, value, sender, recipient)?1340 }1341 CollectionMode::ReFungible => Self::transfer_refungible(1342 target_collection,1343 item_id,1344 value,1345 sender.clone(),1346 recipient.clone(),1347 )?,1348 };13491350 Self::deposit_event(RawEvent::Transfer(1351 target_collection.id,1352 item_id,1353 sender.clone(),1354 recipient.clone(),1355 value,1356 ));13571358 Ok(())1359 }13601361 pub fn approve_internal(1362 sender: &T::CrossAccountId,1363 spender: &T::CrossAccountId,1364 collection: &CollectionHandle<T>,1365 item_id: TokenId,1366 amount: u128,1367 ) -> DispatchResult {1368 Self::token_exists(collection, item_id)?;13691370 // Transfer permissions check1371 let bypasses_limits = collection.limits.owner_can_transfer1372 && Self::is_owner_or_admin_permissions(collection, sender)?;13731374 let allowance_limit = if bypasses_limits {1375 None1376 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {1377 Some(amount)1378 } else {1379 fail!(Error::<T>::NoPermission);1380 };13811382 if collection.access == AccessMode::WhiteList {1383 Self::check_white_list(collection, sender)?;1384 Self::check_white_list(collection, spender)?;1385 }13861387 collection.consume_sload()?;1388 let allowance: u128 = amount1389 .checked_add(<Allowances<T>>::get(1390 collection.id,1391 (item_id, sender.as_sub(), spender.as_sub()),1392 ))1393 .ok_or(Error::<T>::NumOverflow)?;1394 if let Some(limit) = allowance_limit {1395 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1396 }1397 collection.consume_sstore()?;1398 <Allowances<T>>::insert(1399 collection.id,1400 (item_id, sender.as_sub(), spender.as_sub()),1401 allowance,1402 );14031404 if matches!(collection.mode, CollectionMode::NFT) {1405 // TODO: NFT: only one owner may exist for token in ERC7211406 collection.log(ERC721Events::Approval {1407 owner: *sender.as_eth(),1408 approved: *spender.as_eth(),1409 token_id: item_id.into(),1410 })?;1411 }14121413 if matches!(collection.mode, CollectionMode::Fungible(_)) {1414 // TODO: NFT: only one owner may exist for token in ERC201415 collection.log(ERC20Events::Approval {1416 owner: *sender.as_eth(),1417 spender: *spender.as_eth(),1418 value: allowance.into(),1419 })?;1420 }14211422 Self::deposit_event(RawEvent::Approved(1423 collection.id,1424 item_id,1425 sender.clone(),1426 spender.clone(),1427 allowance,1428 ));1429 Ok(())1430 }14311432 pub fn transfer_from_internal(1433 sender: &T::CrossAccountId,1434 from: &T::CrossAccountId,1435 recipient: &T::CrossAccountId,1436 collection: &CollectionHandle<T>,1437 item_id: TokenId,1438 amount: u128,1439 ) -> DispatchResult {1440 if sender == from {1441 // Transfer by `from`, because it is either equal to sender, or derived from him1442 return Self::transfer_internal(from, recipient, collection, item_id, amount);1443 }14441445 // Check approval1446 collection.consume_sload()?;1447 let approval: u128 =1448 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14491450 // Limits check1451 Self::is_correct_transfer(collection, recipient)?;14521453 // Transfer permissions check1454 ensure!(1455 approval >= amount1456 || (collection.limits.owner_can_transfer1457 && Self::is_owner_or_admin_permissions(collection, sender)?),1458 Error::<T>::NoPermission1459 );14601461 if collection.access == AccessMode::WhiteList {1462 Self::check_white_list(collection, sender)?;1463 Self::check_white_list(collection, recipient)?;1464 }14651466 // Reduce approval by transferred amount or remove if remaining approval drops to 01467 let allowance = approval.saturating_sub(amount);1468 collection.consume_sstore()?;1469 if allowance > 0 {1470 <Allowances<T>>::insert(1471 collection.id,1472 (item_id, from.as_sub(), sender.as_sub()),1473 allowance,1474 );1475 } else {1476 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1477 }14781479 match collection.mode {1480 CollectionMode::NFT => {1481 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1482 }1483 CollectionMode::Fungible(_) => {1484 Self::transfer_fungible(collection, amount, from, recipient)?1485 }1486 CollectionMode::ReFungible => Self::transfer_refungible(1487 collection,1488 item_id,1489 amount,1490 from.clone(),1491 recipient.clone(),1492 )?,1493 };14941495 if matches!(collection.mode, CollectionMode::Fungible(_)) {1496 collection.log(ERC20Events::Approval {1497 owner: *from.as_eth(),1498 spender: *sender.as_eth(),1499 value: allowance.into(),1500 })?;1501 }15021503 Ok(())1504 }15051506 pub fn set_variable_meta_data_internal(1507 sender: &T::CrossAccountId,1508 collection: &CollectionHandle<T>,1509 item_id: TokenId,1510 data: Vec<u8>,1511 ) -> DispatchResult {1512 Self::token_exists(collection, item_id)?;15131514 ensure!(1515 CUSTOM_DATA_LIMIT >= data.len() as u32,1516 Error::<T>::TokenVariableDataLimitExceeded1517 );15181519 ensure!(1520 (Self::is_item_owner(sender, collection, item_id)?1521 && collection.meta_update_permission == MetaUpdatePermission::ItemOwner)1522 || (Self::is_owner_or_admin_permissions(collection, sender)?1523 && collection.meta_update_permission == MetaUpdatePermission::Admin),1524 Error::<T>::NoPermission1525 );15261527 match collection.mode {1528 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1529 CollectionMode::ReFungible => {1530 Self::set_re_fungible_variable_data(collection, item_id, data)?1531 }1532 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1533 };15341535 Ok(())1536 }15371538 pub fn meta_update_check(1539 sender: &T::CrossAccountId,1540 collection: &CollectionHandle<T>,1541 item_id: TokenId,1542 ) -> DispatchResult {1543 match collection.meta_update_permission {1544 MetaUpdatePermission::ItemOwner => ensure!(1545 Self::is_item_owner(sender, collection, item_id)?,1546 Error::<T>::NoPermission1547 ),1548 MetaUpdatePermission::Admin => ensure!(1549 Self::is_owner_or_admin_permissions(collection, sender)?,1550 Error::<T>::NoPermission1551 ),1552 MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),1553 }15541555 Ok(())1556 }15571558 pub fn get_variable_metadata(1559 collection: &CollectionHandle<T>,1560 item_id: TokenId,1561 ) -> Result<Vec<u8>, DispatchError> {1562 Ok(match collection.mode {1563 CollectionMode::NFT => {1564 <NftItemList<T>>::get(collection.id, item_id)1565 .ok_or(Error::<T>::TokenNotFound)?1566 .variable_data1567 }1568 CollectionMode::ReFungible => {1569 <ReFungibleItemList<T>>::get(collection.id, item_id)1570 .ok_or(Error::<T>::TokenNotFound)?1571 .variable_data1572 }1573 _ => fail!(Error::<T>::UnexpectedCollectionType),1574 })1575 }15761577 pub fn create_multiple_items_internal(1578 sender: &T::CrossAccountId,1579 collection: &CollectionHandle<T>,1580 owner: &T::CrossAccountId,1581 items_data: Vec<CreateItemData>,1582 ) -> DispatchResult {1583 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15841585 for data in &items_data {1586 Self::validate_create_item_args(collection, data)?;1587 }1588 for data in &items_data {1589 Self::create_item_no_validation(collection, owner, data.clone())?;1590 }15911592 Ok(())1593 }15941595 pub fn burn_item_internal(1596 sender: &T::CrossAccountId,1597 collection: &CollectionHandle<T>,1598 item_id: TokenId,1599 item_owner: &T::CrossAccountId,1600 value: u128,1601 ) -> DispatchResult {1602 ensure!(1603 Self::is_item_owner(sender, collection, item_id)?1604 || (collection.limits.owner_can_transfer1605 && Self::is_owner_or_admin_permissions(collection, sender)?),1606 Error::<T>::NoPermission1607 );16081609 if collection.access == AccessMode::WhiteList {1610 Self::check_white_list(collection, sender)?;1611 }16121613 match collection.mode {1614 CollectionMode::NFT => match value {1615 1 => Self::burn_nft_item(collection, item_id)?,1616 0 => (),1617 _ => fail!(<Error<T>>::TokenValueTooLow),1618 },1619 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection, owner, value)?,1620 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, owner, value)?,1621 _ => (),1622 };16231624 Ok(())1625 }16261627 pub fn toggle_white_list_internal(1628 sender: &T::CrossAccountId,1629 collection: &CollectionHandle<T>,1630 address: &T::CrossAccountId,1631 whitelisted: bool,1632 ) -> DispatchResult {1633 Self::check_owner_or_admin_permissions(collection, sender)?;16341635 if whitelisted {1636 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1637 } else {1638 <WhiteList<T>>::remove(collection.id, address.as_sub());1639 }16401641 Ok(())1642 }16431644 fn is_correct_transfer(1645 collection: &CollectionHandle<T>,1646 recipient: &T::CrossAccountId,1647 ) -> DispatchResult {1648 let collection_id = collection.id;16491650 // check token limit and account token limit1651 collection.consume_sload()?;1652 let account_items: u32 =1653 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;16541655 // zero limit means collection limit is disabled1656 // otherwise get lower value1657 let limit = if collection.limits.account_token_ownership_limit == 01658 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1659 {1660 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1661 } else {1662 collection.limits.account_token_ownership_limit1663 };16641665 ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);16661667 // preliminary transfer check1668 ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);16691670 Ok(())1671 }16721673 fn can_create_items_in_collection(1674 collection: &CollectionHandle<T>,1675 sender: &T::CrossAccountId,1676 owner: &T::CrossAccountId,1677 amount: u32,1678 ) -> DispatchResult {1679 let collection_id = collection.id;16801681 // check token limit and account token limit1682 let total_items: u32 = ItemListIndex::get(collection_id)1683 .checked_add(amount)1684 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1685 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1686 as u32)1687 .checked_add(amount)1688 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;16891690 // zero limit means collection limit is disabled1691 // otherwise get lower value1692 let account_token_limit = if collection.limits.account_token_ownership_limit == 01693 || collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT1694 {1695 ACCOUNT_TOKEN_OWNERSHIP_LIMIT1696 } else {1697 collection.limits.account_token_ownership_limit1698 };16991700 ensure!(1701 collection.limits.token_limit >= total_items,1702 Error::<T>::CollectionTokenLimitExceeded1703 );1704 ensure!(1705 account_token_limit >= account_items,1706 Error::<T>::AccountTokenLimitExceeded1707 );17081709 if !Self::is_owner_or_admin_permissions(collection, sender)? {1710 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1711 Self::check_white_list(collection, owner)?;1712 Self::check_white_list(collection, sender)?;1713 }17141715 Ok(())1716 }17171718 fn validate_create_item_args(1719 target_collection: &CollectionHandle<T>,1720 data: &CreateItemData,1721 ) -> DispatchResult {1722 match target_collection.mode {1723 CollectionMode::NFT => {1724 if !matches!(data, CreateItemData::NFT(_)) {1725 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1726 }1727 }1728 CollectionMode::Fungible(_) => {1729 if !matches!(data, CreateItemData::Fungible(_)) {1730 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1731 }1732 }1733 CollectionMode::ReFungible => {1734 if let CreateItemData::ReFungible(data) = data {1735 // Check refungibility limits1736 ensure!(1737 data.pieces <= MAX_REFUNGIBLE_PIECES,1738 Error::<T>::WrongRefungiblePieces1739 );1740 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1741 } else {1742 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1743 }1744 }1745 };17461747 Ok(())1748 }17491750 fn create_item_no_validation(1751 collection: &CollectionHandle<T>,1752 owner: &T::CrossAccountId,1753 data: CreateItemData,1754 ) -> DispatchResult {1755 match data {1756 CreateItemData::NFT(data) => {1757 let item = NftItemType {1758 owner: owner.clone(),1759 const_data: data.const_data.into_inner(),1760 variable_data: data.variable_data.into_inner(),1761 };17621763 Self::add_nft_item(collection, item)?;1764 }1765 CreateItemData::Fungible(data) => {1766 Self::add_fungible_item(collection, owner, data.value)?;1767 }1768 CreateItemData::ReFungible(data) => {1769 let owner_list = vec![Ownership {1770 owner: owner.clone(),1771 fraction: data.pieces,1772 }];17731774 let item = ReFungibleItemType {1775 owner: owner_list,1776 const_data: data.const_data.into_inner(),1777 variable_data: data.variable_data.into_inner(),1778 };17791780 Self::add_refungible_item(collection, item)?;1781 }1782 };17831784 Ok(())1785 }17861787 fn add_fungible_item(1788 collection: &CollectionHandle<T>,1789 owner: &T::CrossAccountId,1790 value: u128,1791 ) -> DispatchResult {1792 let collection_id = collection.id;17931794 // Does new owner already have an account?1795 collection.consume_sload()?;1796 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17971798 // Mint1799 let item = FungibleItemType {1800 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1801 };1802 collection.consume_sstore()?;1803 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);18041805 // Update balance1806 collection.consume_sload()?;1807 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1808 .checked_add(value)1809 .ok_or(Error::<T>::NumOverflow)?;1810 collection.consume_sstore()?;1811 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18121813 collection.log(ERC20Events::Transfer {1814 from: H160::default(),1815 to: *owner.as_eth(),1816 value: value.into(),1817 })?;1818 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1819 Ok(())1820 }18211822 fn add_refungible_item(1823 collection: &CollectionHandle<T>,1824 item: ReFungibleItemType<T::CrossAccountId>,1825 ) -> DispatchResult {1826 let collection_id = collection.id;18271828 let current_index = <ItemListIndex>::get(collection_id)1829 .checked_add(1)1830 .ok_or(Error::<T>::NumOverflow)?;1831 let itemcopy = item.clone();18321833 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1834 let item_owner = item.owner.first().expect("only one owner is defined");18351836 let value = item_owner.fraction;1837 let owner = item_owner.owner.clone();18381839 Self::add_token_index(collection, current_index, &owner)?;18401841 <ItemListIndex>::insert(collection_id, current_index);1842 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18431844 // Update balance1845 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1846 .checked_add(value)1847 .ok_or(Error::<T>::NumOverflow)?;1848 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18491850 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1851 Ok(())1852 }18531854 fn add_nft_item(1855 collection: &CollectionHandle<T>,1856 item: NftItemType<T::CrossAccountId>,1857 ) -> DispatchResult {1858 let collection_id = collection.id;18591860 let current_index = <ItemListIndex>::get(collection_id)1861 .checked_add(1)1862 .ok_or(Error::<T>::NumOverflow)?;18631864 let item_owner = item.owner.clone();1865 Self::add_token_index(collection, current_index, &item.owner)?;18661867 <ItemListIndex>::insert(collection_id, current_index);1868 <NftItemList<T>>::insert(collection_id, current_index, item);18691870 // Update balance1871 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1872 .checked_add(1)1873 .ok_or(Error::<T>::NumOverflow)?;1874 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18751876 collection.log(ERC721Events::Transfer {1877 from: H160::default(),1878 to: *item_owner.as_eth(),1879 token_id: current_index.into(),1880 })?;1881 Self::deposit_event(RawEvent::ItemCreated(1882 collection_id,1883 current_index,1884 item_owner,1885 ));1886 Ok(())1887 }18881889 fn burn_refungible_item(1890 collection: &CollectionHandle<T>,1891 item_id: TokenId,1892 owner: &T::CrossAccountId,1893 value: u128,1894 ) -> DispatchResult {1895 let collection_id = collection.id;18961897 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1898 .ok_or(Error::<T>::TokenNotFound)?;1899 let mut rft_balance = token1900 .owner1901 .iter()1902 .find(|&i| i.owner == *owner)1903 .ok_or(Error::<T>::TokenNotFound)?1904 .clone();1905 Self::remove_token_index(collection, item_id, owner)?;19061907 // update balance1908 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1909 .checked_sub(value)1910 .ok_or(Error::<T>::NumOverflow)?;1911 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);19121913 rft_balance.fraction = (rft_balance.fraction)1914 .checked_sub(value)1915 .ok_or(Error::<T>::NumOverflow)?;19161917 let index = token1918 .owner1919 .iter()1920 .position(|i| i.owner == *owner)1921 .expect("owned item is exists");1922 if rft_balance.fraction == 0 {1923 // Re-create owners list with sender removed1924 token.owner.remove(index);1925 } else {1926 token.owner[index] = rft_balance;1927 }19281929 let owner_count = token.owner.len();19301931 // Burn the token completely if this was the last (only) owner1932 if owner_count == 0 {1933 <ReFungibleItemList<T>>::remove(collection_id, item_id);1934 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1935 } else {1936 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1937 }19381939 Ok(())1940 }19411942 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1943 let collection_id = collection.id;19441945 let item =1946 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1947 Self::remove_token_index(collection, item_id, &item.owner)?;19481949 // update balance1950 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1951 .checked_sub(1)1952 .ok_or(Error::<T>::NumOverflow)?;1953 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1954 <NftItemList<T>>::remove(collection_id, item_id);1955 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19561957 collection.log(ERC721Events::Transfer {1958 from: *item.owner.as_eth(),1959 to: H160::default(),1960 token_id: item_id.into(),1961 })?;1962 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1963 Ok(())1964 }19651966 fn burn_fungible_item(1967 collection: &CollectionHandle<T>,1968 owner: &T::CrossAccountId,1969 value: u128,1970 ) -> DispatchResult {1971 let collection_id = collection.id;19721973 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1974 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19751976 // update balance1977 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1978 .checked_sub(value)1979 .ok_or(Error::<T>::NumOverflow)?;1980 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19811982 if balance.value - value > 0 {1983 balance.value -= value;1984 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1985 } else {1986 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1987 }19881989 collection.log(ERC20Events::Transfer {1990 from: *owner.as_eth(),1991 to: H160::default(),1992 value: value.into(),1993 })?;1994 Ok(())1995 }19961997 pub fn get_collection(1998 collection_id: CollectionId,1999 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2000 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)2001 }20022003 fn check_owner_permissions(2004 target_collection: &CollectionHandle<T>,2005 subject: &T::AccountId,2006 ) -> DispatchResult {2007 ensure!(2008 *subject == target_collection.owner,2009 Error::<T>::NoPermission2010 );20112012 Ok(())2013 }20142015 fn is_owner_or_admin_permissions(2016 collection: &CollectionHandle<T>,2017 subject: &T::CrossAccountId,2018 ) -> Result<bool, DispatchError> {2019 collection.consume_sload()?;2020 Ok(*subject.as_sub() == collection.owner2021 || <AdminList<T>>::get(collection.id).contains(subject))2022 }20232024 fn check_owner_or_admin_permissions(2025 collection: &CollectionHandle<T>,2026 subject: &T::CrossAccountId,2027 ) -> DispatchResult {2028 ensure!(2029 Self::is_owner_or_admin_permissions(collection, subject)?,2030 Error::<T>::NoPermission2031 );20322033 Ok(())2034 }20352036 fn owned_amount(2037 subject: &T::CrossAccountId,2038 collection: &CollectionHandle<T>,2039 item_id: TokenId,2040 ) -> Result<Option<u128>, DispatchError> {2041 collection.consume_sload()?;2042 Ok(Self::owned_amount_unchecked(subject, collection, item_id))2043 }20442045 fn owned_amount_unchecked(2046 subject: &T::CrossAccountId,2047 target_collection: &CollectionHandle<T>,2048 item_id: TokenId,2049 ) -> Option<u128> {2050 let collection_id = target_collection.id;20512052 match target_collection.mode {2053 CollectionMode::NFT => {2054 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)2055 }2056 CollectionMode::Fungible(_) => {2057 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)2058 }2059 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2060 .owner2061 .iter()2062 .find(|i| i.owner == *subject)2063 .map(|i| i.fraction),2064 }2065 }20662067 fn is_item_owner(2068 subject: &T::CrossAccountId,2069 target_collection: &CollectionHandle<T>,2070 item_id: TokenId,2071 ) -> Result<bool, DispatchError> {2072 Ok(match target_collection.mode {2073 CollectionMode::Fungible(_) => true,2074 _ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),2075 })2076 }20772078 fn check_white_list(2079 collection: &CollectionHandle<T>,2080 address: &T::CrossAccountId,2081 ) -> DispatchResult {2082 collection.consume_sload()?;2083 ensure!(2084 <WhiteList<T>>::contains_key(collection.id, address.as_sub()),2085 Error::<T>::AddresNotInWhiteList,2086 );2087 Ok(())2088 }20892090 /// Check if token exists. In case of Fungible, check if there is an entry for2091 /// the owner in fungible balances double map2092 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2093 let collection_id = target_collection.id;2094 let exists = match target_collection.mode {2095 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2096 CollectionMode::Fungible(_) => true,2097 CollectionMode::ReFungible => {2098 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2099 }2100 };21012102 ensure!(exists, Error::<T>::TokenNotFound);2103 Ok(())2104 }21052106 fn transfer_fungible(2107 collection: &CollectionHandle<T>,2108 value: u128,2109 owner: &T::CrossAccountId,2110 recipient: &T::CrossAccountId,2111 ) -> DispatchResult {2112 let collection_id = collection.id;21132114 collection.consume_sload()?;2115 collection.consume_sload()?;2116 let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());2117 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());21182119 recipient_balance.value = recipient_balance2120 .value2121 .checked_add(value)2122 .ok_or(Error::<T>::NumOverflow)?;2123 balance.value = balance2124 .value2125 .checked_sub(value)2126 .ok_or(Error::<T>::TokenValueTooLow)?;21272128 // update balanceOf2129 collection.consume_sstore()?;2130 collection.consume_sstore()?;2131 if balance.value != 0 {2132 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);2133 } else {2134 <Balance<T>>::remove(collection_id, owner.as_sub());2135 }2136 <Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);21372138 // Reduce or remove sender2139 collection.consume_sstore()?;2140 collection.consume_sstore()?;2141 if balance.value != 0 {2142 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2143 } else {2144 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2145 }2146 <FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);21472148 collection.log(ERC20Events::Transfer {2149 from: *owner.as_eth(),2150 to: *recipient.as_eth(),2151 value: value.into(),2152 })?;2153 Self::deposit_event(RawEvent::Transfer(2154 collection.id,2155 1,2156 owner.clone(),2157 recipient.clone(),2158 value,2159 ));21602161 Ok(())2162 }21632164 fn transfer_refungible(2165 collection: &CollectionHandle<T>,2166 item_id: TokenId,2167 value: u128,2168 owner: T::CrossAccountId,2169 new_owner: T::CrossAccountId,2170 ) -> DispatchResult {2171 let collection_id = collection.id;2172 collection.consume_sload()?;2173 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2174 .ok_or(Error::<T>::TokenNotFound)?;21752176 let item = full_item2177 .owner2178 .iter()2179 .find(|i| i.owner == owner)2180 .ok_or(Error::<T>::TokenNotFound)?;2181 let amount = item.fraction;21822183 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21842185 collection.consume_sload()?;2186 // update balance2187 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2188 .checked_sub(value)2189 .ok_or(Error::<T>::NumOverflow)?;2190 collection.consume_sstore()?;2191 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21922193 collection.consume_sload()?;2194 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2195 .checked_add(value)2196 .ok_or(Error::<T>::NumOverflow)?;2197 collection.consume_sstore()?;2198 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21992200 let old_owner = item.owner.clone();2201 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22022203 let mut new_full_item = full_item.clone();2204 // transfer2205 if amount == value && !new_owner_has_account {2206 // change owner2207 // new owner do not have account2208 new_full_item2209 .owner2210 .iter_mut()2211 .find(|i| i.owner == owner)2212 .expect("old owner does present in refungible")2213 .owner = new_owner.clone();2214 collection.consume_sstore()?;2215 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22162217 // update index collection2218 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;2219 } else {2220 new_full_item2221 .owner2222 .iter_mut()2223 .find(|i| i.owner == owner)2224 .expect("old owner does present in refungible")2225 .fraction -= value;22262227 // separate amount2228 if new_owner_has_account {2229 // new owner has account2230 new_full_item2231 .owner2232 .iter_mut()2233 .find(|i| i.owner == new_owner)2234 .expect("new owner has account")2235 .fraction += value;2236 } else {2237 // new owner do not have account2238 new_full_item.owner.push(Ownership {2239 owner: new_owner.clone(),2240 fraction: value,2241 });2242 Self::add_token_index(collection, item_id, &new_owner)?;2243 }22442245 collection.consume_sstore()?;2246 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2247 }22482249 Self::deposit_event(RawEvent::Transfer(2250 collection.id,2251 item_id,2252 owner,2253 new_owner,2254 amount,2255 ));22562257 Ok(())2258 }22592260 fn transfer_nft(2261 collection: &CollectionHandle<T>,2262 item_id: TokenId,2263 sender: T::CrossAccountId,2264 new_owner: T::CrossAccountId,2265 ) -> DispatchResult {2266 let collection_id = collection.id;2267 collection.consume_sload()?;2268 let mut item =2269 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22702271 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);22722273 collection.consume_sload()?;2274 // update balance2275 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2276 .checked_sub(1)2277 .ok_or(Error::<T>::NumOverflow)?;2278 collection.consume_sstore()?;2279 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22802281 collection.consume_sload()?;2282 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2283 .checked_add(1)2284 .ok_or(Error::<T>::NumOverflow)?;2285 collection.consume_sstore()?;2286 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22872288 // change owner2289 let old_owner = item.owner.clone();2290 item.owner = new_owner.clone();2291 collection.consume_sstore()?;2292 <NftItemList<T>>::insert(collection_id, item_id, item);22932294 // update index collection2295 Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;22962297 collection.log(ERC721Events::Transfer {2298 from: *sender.as_eth(),2299 to: *new_owner.as_eth(),2300 token_id: item_id.into(),2301 })?;2302 Self::deposit_event(RawEvent::Transfer(2303 collection.id,2304 item_id,2305 sender,2306 new_owner,2307 1,2308 ));23092310 Ok(())2311 }23122313 fn set_re_fungible_variable_data(2314 collection: &CollectionHandle<T>,2315 item_id: TokenId,2316 data: Vec<u8>,2317 ) -> DispatchResult {2318 let collection_id = collection.id;2319 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2320 .ok_or(Error::<T>::TokenNotFound)?;23212322 item.variable_data = data;23232324 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23252326 Ok(())2327 }23282329 fn set_nft_variable_data(2330 collection: &CollectionHandle<T>,2331 item_id: TokenId,2332 data: Vec<u8>,2333 ) -> DispatchResult {2334 let collection_id = collection.id;2335 let mut item =2336 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;23372338 item.variable_data = data;23392340 <NftItemList<T>>::insert(collection_id, item_id, item);23412342 Ok(())2343 }23442345 #[allow(dead_code)]2346 fn init_collection(item: &Collection<T>) {2347 // check params2348 assert!(2349 item.decimal_points <= MAX_DECIMAL_POINTS,2350 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2351 );2352 assert!(2353 item.name.len() <= 64,2354 "Collection name can not be longer than 63 char"2355 );2356 assert!(2357 item.name.len() <= 256,2358 "Collection description can not be longer than 255 char"2359 );2360 assert!(2361 item.token_prefix.len() <= 16,2362 "Token prefix can not be longer than 15 char"2363 );23642365 // Generate next collection ID2366 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();23672368 CreatedCollectionCount::put(next_id);2369 }23702371 #[allow(dead_code)]2372 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2373 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23742375 Self::add_token_index(2376 &CollectionHandle::get(collection_id).unwrap(),2377 current_index,2378 &item.owner,2379 )2380 .unwrap();23812382 <ItemListIndex>::insert(collection_id, current_index);23832384 // Update balance2385 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2386 .checked_add(1)2387 .unwrap();2388 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2389 }23902391 #[allow(dead_code)]2392 fn init_fungible_token(2393 collection_id: CollectionId,2394 owner: &T::CrossAccountId,2395 item: &FungibleItemType,2396 ) {2397 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();23982399 Self::add_token_index(2400 &CollectionHandle::get(collection_id).unwrap(),2401 current_index,2402 owner,2403 )2404 .unwrap();24052406 <ItemListIndex>::insert(collection_id, current_index);24072408 // Update balance2409 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2410 .checked_add(item.value)2411 .unwrap();2412 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2413 }24142415 #[allow(dead_code)]2416 fn init_refungible_token(2417 collection_id: CollectionId,2418 item: &ReFungibleItemType<T::CrossAccountId>,2419 ) {2420 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();24212422 let value = item.owner.first().unwrap().fraction;2423 let owner = item.owner.first().unwrap().owner.clone();24242425 Self::add_token_index(2426 &CollectionHandle::get(collection_id).unwrap(),2427 current_index,2428 &owner,2429 )2430 .unwrap();24312432 <ItemListIndex>::insert(collection_id, current_index);24332434 // Update balance2435 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2436 .checked_add(value)2437 .unwrap();2438 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2439 }24402441 fn add_token_index(2442 collection: &CollectionHandle<T>,2443 item_index: TokenId,2444 owner: &T::CrossAccountId,2445 ) -> DispatchResult {2446 collection.consume_sload()?;2447 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2448 if list_exists {2449 collection.consume_sload()?;2450 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());24512452 // bound Owned tokens by a single address in collection2453 let account_items: u32 = list.len() as u32;2454 ensure!(2455 account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2456 Error::<T>::AddressOwnershipLimitExceeded2457 );24582459 let item_contains = list.contains(&item_index.clone());24602461 if !item_contains {2462 list.push(item_index);2463 }24642465 collection.consume_sstore()?;2466 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2467 } else {2468 let itm = vec![item_index];2469 collection.consume_sstore()?;2470 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);2471 }24722473 Ok(())2474 }24752476 fn remove_token_index(2477 collection: &CollectionHandle<T>,2478 item_index: TokenId,2479 owner: &T::CrossAccountId,2480 ) -> DispatchResult {2481 collection.consume_sload()?;2482 let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());2483 if list_exists {2484 collection.consume_sload()?;2485 let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());2486 let item_contains = list.contains(&item_index.clone());24872488 if item_contains {2489 list.retain(|&item| item != item_index);2490 collection.consume_sstore()?;2491 <AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);2492 }2493 }24942495 Ok(())2496 }24972498 fn move_token_index(2499 collection: &CollectionHandle<T>,2500 item_index: TokenId,2501 old_owner: &T::CrossAccountId,2502 new_owner: &T::CrossAccountId,2503 ) -> DispatchResult {2504 Self::remove_token_index(collection, item_index, old_owner)?;2505 Self::add_token_index(collection, item_index, new_owner)?;25062507 Ok(())2508 }2509}25102511sp_api::decl_runtime_apis! {2512 pub trait NftApi {2513 /// Used for ethereum integration2514 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2515 }2516}