difftreelog
Transfer item owner permission removed
in: master
1 file changed
pallets/nft/src/lib.rsdiffbeforeafterboth1#![cfg_attr(not(feature = "std"), no_std)]23/// For more guidance on Substrate FRAME, see the example pallet4/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs5use codec::{Decode, Encode};6pub use frame_support::{7 construct_runtime, decl_event, decl_module, decl_storage,8 dispatch::DispatchResult,9 ensure, parameter_types,10 traits::{11 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,12 Randomness, WithdrawReason,13 },14 weights::{15 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},16 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,17 WeightToFeePolynomial,18 },19 IsSubType, StorageValue,20};2122use frame_system::{self as system, ensure_signed};23use sp_runtime::sp_std::prelude::Vec;24use sp_runtime::{25 traits::{26 DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SaturatedConversion, Saturating,27 SignedExtension, Zero,28 },29 transaction_validity::{30 InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,31 ValidTransaction,32 },33 FixedPointOperand, FixedU128,34};35use sp_std::prelude::*;3637#[cfg(test)]38mod mock;3940#[cfg(test)]41mod tests;4243#[derive(Encode, Decode, Debug, Eq, Clone, PartialEq)]44pub enum CollectionMode {45 Invalid,46 // custom data size47 NFT(u32),48 // decimal points49 Fungible(u32),50 // custom data size and decimal points51 ReFungible(u32, u32),52}5354impl Into<u8> for CollectionMode {55 fn into(self) -> u8 {56 match self {57 CollectionMode::Invalid => 0,58 CollectionMode::NFT(_) => 1,59 CollectionMode::Fungible(_) => 2,60 CollectionMode::ReFungible(_, _) => 3,61 }62 }63}6465#[derive(Encode, Decode, Debug, Clone, PartialEq)]66pub enum AccessMode {67 Normal,68 WhiteList,69}70impl Default for AccessMode {71 fn default() -> Self {72 Self::Normal73 }74}7576impl Default for CollectionMode {77 fn default() -> Self {78 Self::Invalid79 }80}8182#[derive(Encode, Decode, Default, Clone, PartialEq)]83#[cfg_attr(feature = "std", derive(Debug))]84pub struct Ownership<AccountId> {85 pub owner: AccountId,86 pub fraction: u128,87}8889#[derive(Encode, Decode, Default, Clone, PartialEq)]90#[cfg_attr(feature = "std", derive(Debug))]91pub struct CollectionType<AccountId> {92 pub owner: AccountId,93 pub mode: CollectionMode,94 pub access: AccessMode,95 pub decimal_points: u32,96 pub name: Vec<u16>, // 64 include null escape char97 pub description: Vec<u16>, // 256 include null escape char98 pub token_prefix: Vec<u8>, // 16 include null escape char99 pub custom_data_size: u32,100 pub mint_mode: bool,101 pub offchain_schema: Vec<u8>,102 pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender103 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship104}105106#[derive(Encode, Decode, Default, Clone, PartialEq)]107#[cfg_attr(feature = "std", derive(Debug))]108pub struct CollectionAdminsType<AccountId> {109 pub admin: AccountId,110 pub collection_id: u64,111}112113#[derive(Encode, Decode, Default, Clone, PartialEq)]114#[cfg_attr(feature = "std", derive(Debug))]115pub struct NftItemType<AccountId> {116 pub collection: u64,117 pub owner: AccountId,118 pub data: Vec<u8>,119}120121#[derive(Encode, Decode, Default, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Debug))]123pub struct FungibleItemType<AccountId> {124 pub collection: u64,125 pub owner: AccountId,126 pub value: u128,127}128129#[derive(Encode, Decode, Default, Clone, PartialEq)]130#[cfg_attr(feature = "std", derive(Debug))]131pub struct ReFungibleItemType<AccountId> {132 pub collection: u64,133 pub owner: Vec<Ownership<AccountId>>,134 pub data: Vec<u8>,135}136137#[derive(Encode, Decode, Default, Clone, PartialEq)]138#[cfg_attr(feature = "std", derive(Debug))]139pub struct ApprovePermissions<AccountId> {140 pub approved: AccountId,141 pub amount: u64,142}143144#[derive(Encode, Decode, Default, Clone, PartialEq)]145#[cfg_attr(feature = "std", derive(Debug))]146pub struct VestingItem<AccountId, Moment> {147 pub sender: AccountId,148 pub recipient: AccountId,149 pub collection_id: u64,150 pub item_id: u64,151 pub amount: u64,152 pub vesting_date: Moment,153}154155pub trait Trait: system::Trait {156 type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;157}158159decl_storage! {160 trait Store for Module<T: Trait> as Nft {161162 // Private members163 NextCollectionID: u64;164 CreatedCollectionCount: u64;165 ChainVersion: u64;166 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;167168 pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;169 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;170 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;171172 /// Balance owner per collection map173 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;174175 /// second parameter: item id + owner account id176 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;177178 /// Item collections179 pub NftItemList get(fn nft_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;180 pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;181 pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;182183 /// Index list184 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;185186 // Sponsorship187 pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;188 pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;189 }190}191192decl_event!(193 pub enum Event<T>194 where195 AccountId = <T as system::Trait>::AccountId,196 {197 Created(u64, u8, AccountId),198 ItemCreated(u64, u64),199 ItemDestroyed(u64, u64),200 }201);202203decl_module! {204 pub struct Module<T: Trait> for enum Call where origin: T::Origin {205206 fn deposit_event() = default;207208 fn on_initialize(now: T::BlockNumber) -> Weight {209210 if ChainVersion::get() < 2211 {212 let value = NextCollectionID::get();213 CreatedCollectionCount::put(value);214 ChainVersion::put(2);215 }216217 0218 }219220 // Create collection of NFT with given parameters221 //222 // @param customDataSz size of custom data in each collection item223 // returns collection ID224 #[weight = 0]225 pub fn create_collection(origin,226 collection_name: Vec<u16>,227 collection_description: Vec<u16>,228 token_prefix: Vec<u8>,229 mode: CollectionMode) -> DispatchResult {230231 // Anyone can create a collection232 let who = ensure_signed(origin)?;233 let custom_data_size = match mode {234 CollectionMode::NFT(size) => size,235 CollectionMode::ReFungible(size, _) => size,236 _ => 0237 };238239 let decimal_points = match mode {240 CollectionMode::Fungible(points) => points,241 CollectionMode::ReFungible(_, points) => points,242 _ => 0243 };244245 // check params246 ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");247248 let mut name = collection_name.to_vec();249 name.push(0);250 ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");251252 let mut description = collection_description.to_vec();253 description.push(0);254 ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");255256 let mut prefix = token_prefix.to_vec();257 prefix.push(0);258 ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");259260 // Generate next collection ID261 let next_id = CreatedCollectionCount::get()262 .checked_add(1)263 .expect("collection id error");264265 CreatedCollectionCount::put(next_id);266267 // Create new collection268 let new_collection = CollectionType {269 owner: who.clone(),270 name: name,271 mode: mode.clone(),272 mint_mode: false,273 access: AccessMode::Normal,274 description: description,275 decimal_points: decimal_points,276 token_prefix: prefix,277 offchain_schema: Vec::new(),278 custom_data_size: custom_data_size,279 sponsor: T::AccountId::default(),280 unconfirmed_sponsor: T::AccountId::default(),281 };282283 // Add new collection to map284 <Collection<T>>::insert(next_id, new_collection);285286 // call event287 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));288289 Ok(())290 }291292 #[weight = 0]293 pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {294295 let sender = ensure_signed(origin)?;296 Self::check_owner_permissions(collection_id, sender)?;297298 // TODO Items remove299 <AddressTokens<T>>::remove_prefix(collection_id);300 <ApprovedList<T>>::remove_prefix(collection_id);301 <Balance<T>>::remove_prefix(collection_id);302 <ItemListIndex>::remove(collection_id);303 <AdminList<T>>::remove(collection_id);304 <Collection<T>>::remove(collection_id);305 <WhiteList<T>>::remove(collection_id);306307 Ok(())308 }309310 #[weight = 0]311 pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{312313 let sender = ensure_signed(origin)?;314 Self::check_owner_or_admin_permissions(collection_id, sender)?;315316 let mut white_list_collection: Vec<T::AccountId>;317 if <WhiteList<T>>::contains_key(collection_id) {318 white_list_collection = <WhiteList<T>>::get(collection_id);319 if !white_list_collection.contains(&address.clone())320 {321 white_list_collection.push(address.clone());322 }323 }324 else {325 white_list_collection = Vec::new();326 white_list_collection.push(address.clone());327 }328329 <WhiteList<T>>::insert(collection_id, white_list_collection);330 Ok(())331 }332333 #[weight = 0]334 pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{335336 let sender = ensure_signed(origin)?;337 Self::check_owner_or_admin_permissions(collection_id, sender)?;338339 if <WhiteList<T>>::contains_key(collection_id) {340 let mut white_list_collection = <WhiteList<T>>::get(collection_id);341 if white_list_collection.contains(&address.clone())342 {343 white_list_collection.retain(|i| *i != address.clone());344 <WhiteList<T>>::insert(collection_id, white_list_collection);345 }346 }347348 Ok(())349 }350351 #[weight = 0]352 pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult353 {354 let sender = ensure_signed(origin)?;355356 Self::check_owner_permissions(collection_id, sender)?;357 let mut target_collection = <Collection<T>>::get(collection_id);358 target_collection.access = mode;359 <Collection<T>>::insert(collection_id, target_collection);360361 Ok(())362 }363364 #[weight = 0]365 pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult366 {367 let sender = ensure_signed(origin)?;368369 Self::check_owner_permissions(collection_id, sender)?;370 let mut target_collection = <Collection<T>>::get(collection_id);371 target_collection.mint_mode = mint_permission;372 <Collection<T>>::insert(collection_id, target_collection);373374 Ok(())375 }376377 #[weight = 0]378 pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {379380 let sender = ensure_signed(origin)?;381 Self::check_owner_permissions(collection_id, sender)?;382 let mut target_collection = <Collection<T>>::get(collection_id);383 target_collection.owner = new_owner;384 <Collection<T>>::insert(collection_id, target_collection);385386 Ok(())387 }388389 #[weight = 0]390 pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {391392 let sender = ensure_signed(origin)?;393 Self::check_owner_or_admin_permissions(collection_id, sender)?;394 let mut admin_arr: Vec<T::AccountId> = Vec::new();395396 if <AdminList<T>>::contains_key(collection_id)397 {398 admin_arr = <AdminList<T>>::get(collection_id);399 ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");400 }401402 admin_arr.push(new_admin_id);403 <AdminList<T>>::insert(collection_id, admin_arr);404405 Ok(())406 }407408 #[weight = 0]409 pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {410411 let sender = ensure_signed(origin)?;412 Self::check_owner_or_admin_permissions(collection_id, sender)?;413414 if <AdminList<T>>::contains_key(collection_id)415 {416 let mut admin_arr = <AdminList<T>>::get(collection_id);417 admin_arr.retain(|i| *i != account_id);418 <AdminList<T>>::insert(collection_id, admin_arr);419 }420421 Ok(())422 }423424 #[weight = 0]425 pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {426427 let sender = ensure_signed(origin)?;428 ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");429430 let mut target_collection = <Collection<T>>::get(collection_id);431 ensure!(sender == target_collection.owner, "You do not own this collection");432433 target_collection.unconfirmed_sponsor = new_sponsor;434 <Collection<T>>::insert(collection_id, target_collection);435436 Ok(())437 }438439 #[weight = 0]440 pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {441442 let sender = ensure_signed(origin)?;443 ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");444445 let mut target_collection = <Collection<T>>::get(collection_id);446 ensure!(sender == target_collection.unconfirmed_sponsor, "This address is not set as sponsor, use setCollectionSponsor first");447448 target_collection.sponsor = target_collection.unconfirmed_sponsor;449 target_collection.unconfirmed_sponsor = T::AccountId::default();450 <Collection<T>>::insert(collection_id, target_collection);451452 Ok(())453 }454455 #[weight = 0]456 pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {457458 let sender = ensure_signed(origin)?;459 ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");460461 let mut target_collection = <Collection<T>>::get(collection_id);462 ensure!(sender == target_collection.owner, "You do not own this collection");463464 target_collection.sponsor = T::AccountId::default();465 <Collection<T>>::insert(collection_id, target_collection);466467 Ok(())468 }469470 #[weight = 0]471 pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {472473 let sender = ensure_signed(origin)?;474 Self::collection_exists(collection_id)?;475 let target_collection = <Collection<T>>::get(collection_id);476477 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {478 ensure!(target_collection.mint_mode == true, "Collection is not in mint mode");479 Self::check_white_list(collection_id, owner.clone())?;480 }481482 match target_collection.mode483 {484 CollectionMode::NFT(_) => {485486 // check size487 ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");488489 // Create nft item490 let item = NftItemType {491 collection: collection_id,492 owner: owner,493 data: properties,494 };495496 Self::add_nft_item(item)?;497498 },499 CollectionMode::Fungible(_) => {500501 // check size502 ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");503504 let item = FungibleItemType {505 collection: collection_id,506 owner: owner,507 value: (10 as u128).pow(target_collection.decimal_points)508 };509510 Self::add_fungible_item(item)?;511 },512 CollectionMode::ReFungible(_, _) => {513514 // check size515 ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");516517 let mut owner_list = Vec::new();518 let value = (10 as u128).pow(target_collection.decimal_points);519 owner_list.push(Ownership {owner: owner, fraction: value});520521 let item = ReFungibleItemType {522 collection: collection_id,523 owner: owner_list,524 data: properties525 };526527 Self::add_refungible_item(item)?;528 },529 _ => ()530 };531532 // call event533 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));534535 Ok(())536 }537538 #[weight = 0]539 pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {540541 let sender = ensure_signed(origin)?;542 Self::collection_exists(collection_id)?;543 let item_owner = Self::is_item_owner(sender.clone(), collection_id, item_id);544 if !item_owner545 {546 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) { 547 Self::check_white_list(collection_id, sender.clone())?;548 }549 }550 let target_collection = <Collection<T>>::get(collection_id);551552 match target_collection.mode553 {554 CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,555 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection_id, item_id)?,556 CollectionMode::ReFungible(_, _) => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,557 _ => ()558 };559560 // call event561 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));562563 Ok(())564 }565566 #[weight = 0]567 pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {568569 let sender = ensure_signed(origin)?;570571 let item_owner = Self::is_item_owner(sender.clone(), collection_id, item_id);572 if !item_owner {573 Self::check_white_list(collection_id, sender.clone())?;574 Self::check_white_list(collection_id, recipient.clone())?;575 }576577 let target_collection = <Collection<T>>::get(collection_id);578579 match target_collection.mode580 {581 CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,582 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,583 CollectionMode::ReFungible(_, _) => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,584 _ => ()585 };586587 Ok(())588 }589590 #[weight = 0]591 pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {592593 let sender = ensure_signed(origin)?;594595 // amount param stub596 let amount = 100000000;597598 let item_owner = Self::is_item_owner(sender.clone(), collection_id, item_id);599 if !item_owner {600 Self::check_white_list(collection_id, approved.clone())?;601 }602603 let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));604 if list_exists {605606 let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));607 let item_contains = list.iter().any(|i| i.approved == approved);608609 if !item_contains {610 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });611 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);612 }613 } else {614615 let mut list = Vec::new();616 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });617 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);618 }619620 Ok(())621 }622623 #[weight = 0]624 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {625626 let sender = ensure_signed(origin)?;627 let approved_list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone()));628629 ensure!(approved_list_exists, "Only approved addresses can call this method");630631 Self::check_white_list(collection_id, from.clone())?;632 Self::check_white_list(collection_id, recipient.clone())?;633634 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));635 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());636 ensure!(opt_item.is_some(), "No approve found");637 ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");638639 // remove approve640 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))641 .into_iter().filter(|i| i.approved != sender.clone()).collect();642 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);643644 let target_collection = <Collection<T>>::get(collection_id);645646 match target_collection.mode647 {648 CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,649 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,650 CollectionMode::ReFungible(_, _) => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,651 _ => ()652 };653654 Ok(())655 }656657 #[weight = 0]658 pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {659660 // let no_perm_mes = "You do not have permissions to modify this collection";661 // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);662 // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));663 // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);664665 // // on_nft_received call666667 // Self::transfer(origin, collection_id, item_id, new_owner)?;668669 Ok(())670 }671672 #[weight = 0]673 pub fn set_offchain_schema(674 origin,675 collection_id: u64,676 schema: Vec<u8>677 ) -> DispatchResult {678 let sender = ensure_signed(origin)?;679 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;680681 let mut target_collection = <Collection<T>>::get(collection_id);682 target_collection.offchain_schema = schema;683 <Collection<T>>::insert(collection_id, target_collection);684685 Ok(())686 }687 }688}689690impl<T: Trait> Module<T> {691 fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {692 let current_index = <ItemListIndex>::get(item.collection)693 .checked_add(1)694 .expect("Item list index id error");695 let itemcopy = item.clone();696 let owner = item.owner.clone();697 let value = item.value as u64;698699 Self::add_token_index(item.collection, current_index, owner.clone())?;700701 <ItemListIndex>::insert(item.collection, current_index);702 <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);703704 // Update balance705 let new_balance = <Balance<T>>::get(item.collection, owner.clone())706 .checked_add(value)707 .unwrap();708 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);709710 Ok(())711 }712713 fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {714 let current_index = <ItemListIndex>::get(item.collection)715 .checked_add(1)716 .expect("Item list index id error");717 let itemcopy = item.clone();718719 let value = item.owner.first().unwrap().fraction as u64;720 let owner = item.owner.first().unwrap().owner.clone();721722 Self::add_token_index(item.collection, current_index, owner.clone())?;723724 <ItemListIndex>::insert(item.collection, current_index);725 <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);726727 // Update balance728 let new_balance = <Balance<T>>::get(item.collection, owner.clone())729 .checked_add(value)730 .unwrap();731 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);732733 Ok(())734 }735736 fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {737 let current_index = <ItemListIndex>::get(item.collection)738 .checked_add(1)739 .expect("Item list index id error");740741 let item_owner = item.owner.clone();742 let collection_id = item.collection.clone();743 Self::add_token_index(collection_id, current_index, item.owner.clone())?;744745 <ItemListIndex>::insert(collection_id, current_index);746 <NftItemList<T>>::insert(collection_id, current_index, item);747748 // Update balance749 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())750 .checked_add(1)751 .unwrap();752 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);753754 Ok(())755 }756757 fn burn_refungible_item(collection_id: u64, item_id: u64, owner: T::AccountId) -> DispatchResult {758 ensure!(759 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),760 "Item does not exists"761 );762 let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);763 let item = collection764 .owner765 .iter()766 .filter(|&i| i.owner == owner)767 .next()768 .unwrap();769 Self::remove_token_index(collection_id, item_id, owner.clone())?;770771 // remove approve list772 <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));773774 // update balance775 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())776 .checked_sub(item.fraction as u64)777 .unwrap();778 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);779780 <ReFungibleItemList<T>>::remove(collection_id, item_id);781782 Ok(())783 }784785 fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {786 ensure!(787 <NftItemList<T>>::contains_key(collection_id, item_id),788 "Item does not exists"789 );790 let item = <NftItemList<T>>::get(collection_id, item_id);791 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;792793 // remove approve list794 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));795796 // update balance797 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())798 .checked_sub(1)799 .unwrap();800 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);801 <NftItemList<T>>::remove(collection_id, item_id);802803 Ok(())804 }805806 fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {807 ensure!(808 <FungibleItemList<T>>::contains_key(collection_id, item_id),809 "Item does not exists"810 );811 let item = <FungibleItemList<T>>::get(collection_id, item_id);812 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;813814 // remove approve list815 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));816817 // update balance818 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())819 .checked_sub(item.value as u64)820 .unwrap();821 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);822823 <FungibleItemList<T>>::remove(collection_id, item_id);824825 Ok(())826 }827828 fn collection_exists(collection_id: u64) -> DispatchResult {829 ensure!(830 <Collection<T>>::contains_key(collection_id),831 "This collection does not exist"832 );833 Ok(())834 }835836 fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {837 Self::collection_exists(collection_id)?;838839 let target_collection = <Collection<T>>::get(collection_id);840 ensure!(841 subject == target_collection.owner,842 "You do not own this collection"843 );844845 Ok(())846 }847848 fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {849850 let target_collection = <Collection<T>>::get(collection_id);851 let mut result: bool = subject == target_collection.owner;852 let exists = <AdminList<T>>::contains_key(collection_id);853854 if !result & exists {855 if <AdminList<T>>::get(collection_id).contains(&subject) {856 result = true857 }858 }859860 result861 }862863 fn check_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {864 865 Self::collection_exists(collection_id)?;866 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());867868 ensure!(result, "You do not have permissions to modify this collection");869 Ok(())870 }871872 fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {873 let target_collection = <Collection<T>>::get(collection_id);874875 match target_collection.mode {876 CollectionMode::NFT(_) => {877 <NftItemList<T>>::get(collection_id, item_id).owner == subject878 }879 CollectionMode::Fungible(_) => {880 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject881 }882 CollectionMode::ReFungible(_, _) => {883 <ReFungibleItemList<T>>::get(collection_id, item_id)884 .owner885 .iter()886 .any(|i| i.owner == subject)887 }888 CollectionMode::Invalid => false,889 }890 }891892 fn check_white_list(collection_id: u64, address: T::AccountId) -> DispatchResult {893894 let mes = "Address is not in white list";895 ensure!(<WhiteList<T>>::contains_key(collection_id), mes);896 let wl = <WhiteList<T>>::get(collection_id);897 ensure!(wl.contains(&address.clone()), mes);898899 Ok(())900 }901902 fn transfer_fungible(903 collection_id: u64,904 item_id: u64,905 value: u64,906 owner: T::AccountId,907 new_owner: T::AccountId,908 ) -> DispatchResult {909910 ensure!(911 <FungibleItemList<T>>::contains_key(collection_id, item_id),912 "Item not exists"913 );914915 let full_item = <FungibleItemList<T>>::get(collection_id, item_id);916 let amount = full_item.value;917918 ensure!(amount >= value.into(), "Item balance not enouth");919920 // update balance921 let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())922 .checked_sub(value)923 .unwrap();924 <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);925926 let mut new_owner_account_id = 0;927 let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());928 if new_owner_items.len() > 0 {929 new_owner_account_id = new_owner_items[0];930 }931932 let val64 = value.into();933934 // transfer935 if amount == val64 && new_owner_account_id == 0 {936 // change owner937 // new owner do not have account938 let mut new_full_item = full_item.clone();939 new_full_item.owner = new_owner.clone();940 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);941942 // update balance943 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())944 .checked_add(value)945 .unwrap();946 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);947948 // update index collection949 Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;950 } else {951 let mut new_full_item = full_item.clone();952 new_full_item.value -= val64;953954 // separate amount955 if new_owner_account_id > 0 {956 // new owner has account957 let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);958 item.value += val64;959960 // update balance961 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())962 .checked_add(value)963 .unwrap();964 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);965966 <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);967 } else {968 // new owner do not have account969 let item = FungibleItemType {970 collection: collection_id,971 owner: new_owner.clone(),972 value: val64,973 };974975 Self::add_fungible_item(item)?;976 }977978 if amount == val64 {979 Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;980981 // remove approve list982 <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));983 <FungibleItemList<T>>::remove(collection_id, item_id);984 }985986 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);987 }988989 Ok(())990 }991992 fn transfer_refungible(993 collection_id: u64,994 item_id: u64,995 value: u64,996 owner: T::AccountId,997 new_owner: T::AccountId,998 ) -> DispatchResult {9991000 ensure!(1001 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1002 "Item not exists"1003 );10041005 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1006 let item = full_item1007 .owner1008 .iter()1009 .filter(|i| i.owner == owner)1010 .next()1011 .unwrap();1012 let amount = item.fraction;10131014 ensure!(amount >= value.into(), "Item balance not enouth");10151016 // update balance1017 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1018 .checked_sub(value)1019 .unwrap();1020 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);10211022 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1023 .checked_add(value)1024 .unwrap();1025 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);10261027 let old_owner = item.owner.clone();1028 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1029 let val64 = value.into();10301031 // transfer1032 if amount == val64 && !new_owner_has_account {1033 // change owner1034 // new owner do not have account1035 let mut new_full_item = full_item.clone();1036 new_full_item1037 .owner1038 .iter_mut()1039 .find(|i| i.owner == owner)1040 .unwrap()1041 .owner = new_owner.clone();1042 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);10431044 // update index collection1045 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1046 } else {1047 let mut new_full_item = full_item.clone();1048 new_full_item1049 .owner1050 .iter_mut()1051 .find(|i| i.owner == owner)1052 .unwrap()1053 .fraction -= val64;10541055 // separate amount1056 if new_owner_has_account {1057 // new owner has account1058 new_full_item1059 .owner1060 .iter_mut()1061 .find(|i| i.owner == new_owner)1062 .unwrap()1063 .fraction += val64;1064 } else {1065 // new owner do not have account1066 new_full_item.owner.push(Ownership {1067 owner: new_owner.clone(),1068 fraction: val64,1069 });1070 Self::add_token_index(collection_id, item_id, new_owner.clone())?;1071 }10721073 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1074 }10751076 Ok(())1077 }10781079 fn transfer_nft(1080 collection_id: u64,1081 item_id: u64,1082 sender: T::AccountId,1083 new_owner: T::AccountId,1084 ) -> DispatchResult {1085 1086 ensure!(1087 <NftItemList<T>>::contains_key(collection_id, item_id),1088 "Item not exists"1089 );10901091 let mut item = <NftItemList<T>>::get(collection_id, item_id);10921093 ensure!(1094 sender == item.owner,1095 "sender parameter and item owner must be equal"1096 );10971098 // update balance1099 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1100 .checked_sub(1)1101 .unwrap();1102 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);11031104 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1105 .checked_add(1)1106 .unwrap();1107 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);11081109 // change owner1110 let old_owner = item.owner.clone();1111 item.owner = new_owner.clone();1112 <NftItemList<T>>::insert(collection_id, item_id, item);11131114 // update index collection1115 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;11161117 // reset approved list1118 <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1119 Ok(())1120 }11211122 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {1123 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1124 if list_exists {1125 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1126 let item_contains = list.contains(&item_index.clone());11271128 if !item_contains {1129 list.push(item_index.clone());1130 }11311132 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);1133 } else {1134 let mut itm = Vec::new();1135 itm.push(item_index.clone());1136 <AddressTokens<T>>::insert(collection_id, owner, itm);1137 }11381139 Ok(())1140 }11411142 fn remove_token_index(1143 collection_id: u64,1144 item_index: u64,1145 owner: T::AccountId,1146 ) -> DispatchResult {1147 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1148 if list_exists {1149 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1150 let item_contains = list.contains(&item_index.clone());11511152 if item_contains {1153 list.retain(|&item| item != item_index);1154 <AddressTokens<T>>::insert(collection_id, owner, list);1155 }1156 }11571158 Ok(())1159 }11601161 fn move_token_index(1162 collection_id: u64,1163 item_index: u64,1164 old_owner: T::AccountId,1165 new_owner: T::AccountId,1166 ) -> DispatchResult {1167 Self::remove_token_index(collection_id, item_index, old_owner)?;1168 Self::add_token_index(collection_id, item_index, new_owner)?;11691170 Ok(())1171 }1172}11731174////////////////////////////////////////////////////////////////////////////////////////////////////1175// Economic models11761177/// Fee multiplier.1178pub type Multiplier = FixedU128;11791180type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1181 <T as system::Trait>::AccountId,1182>>::Balance;1183type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1184 <T as system::Trait>::AccountId,1185>>::NegativeImbalance;11861187/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1188/// in the queue.1189#[derive(Encode, Decode, Clone, Eq, PartialEq)]1190pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(1191 #[codec(compact)] BalanceOf<T>,1192);11931194impl<T: Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug1195 for ChargeTransactionPayment<T>1196{1197 #[cfg(feature = "std")]1198 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1199 write!(f, "ChargeTransactionPayment<{:?}>", self.0)1200 }1201 #[cfg(not(feature = "std"))]1202 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1203 Ok(())1204 }1205}12061207impl<T: Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T>1208where1209 T::Call:1210 Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1211 BalanceOf<T>: Send + Sync + FixedPointOperand,1212{1213 /// utility constructor. Used only in client/factory code.1214 pub fn from(fee: BalanceOf<T>) -> Self {1215 Self(fee)1216 }12171218 pub fn traditional_fee(1219 len: usize,1220 info: &DispatchInfoOf<T::Call>,1221 tip: BalanceOf<T>,1222 ) -> BalanceOf<T>1223 where1224 T::Call: Dispatchable<Info = DispatchInfo>,1225 {1226 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1227 }12281229 fn withdraw_fee(1230 &self,1231 who: &T::AccountId,1232 call: &T::Call,1233 info: &DispatchInfoOf<T::Call>,1234 len: usize,1235 ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1236 let tip = self.0;12371238 // Set fee based on call type. Creating collection costs 1 Unique.1239 // All other transactions have traditional fees so far1240 let fee = match call.is_sub_type() {1241 Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1242 _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes1243 // _ => <BalanceOf<T>>::from(100)1244 };12451246 // Determine who is paying transaction fee based on ecnomic model1247 // Parse call to extract collection ID and access collection sponsor1248 let sponsor: T::AccountId = match call.is_sub_type() {1249 Some(Call::create_item(collection_id, _properties, _owner)) => {1250 <Collection<T>>::get(collection_id).sponsor1251 }1252 Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1253 <Collection<T>>::get(collection_id).sponsor1254 }12551256 _ => T::AccountId::default(),1257 };12581259 let mut who_pays_fee: T::AccountId = sponsor.clone();1260 if sponsor == T::AccountId::default() {1261 who_pays_fee = who.clone();1262 }12631264 // Only mess with balances if fee is not zero.1265 if fee.is_zero() {1266 return Ok((fee, None));1267 }12681269 match <T as transaction_payment::Trait>::Currency::withdraw(1270 &who_pays_fee,1271 fee,1272 if tip.is_zero() {1273 WithdrawReason::TransactionPayment.into()1274 } else {1275 WithdrawReason::TransactionPayment | WithdrawReason::Tip1276 },1277 ExistenceRequirement::KeepAlive,1278 ) {1279 Ok(imbalance) => Ok((fee, Some(imbalance))),1280 Err(_) => Err(InvalidTransaction::Payment.into()),1281 }1282 }1283}12841285impl<T: Trait + transaction_payment::Trait + Send + Sync> SignedExtension1286 for ChargeTransactionPayment<T>1287where1288 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1289 T::Call:1290 Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1291{1292 const IDENTIFIER: &'static str = "ChargeTransactionPayment";1293 type AccountId = T::AccountId;1294 type Call = T::Call;1295 type AdditionalSigned = ();1296 type Pre = (1297 BalanceOf<T>,1298 Self::AccountId,1299 Option<NegativeImbalanceOf<T>>,1300 BalanceOf<T>,1301 );1302 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {1303 Ok(())1304 }13051306 fn validate(1307 &self,1308 who: &Self::AccountId,1309 call: &Self::Call,1310 info: &DispatchInfoOf<Self::Call>,1311 len: usize,1312 ) -> TransactionValidity {1313 let (fee, _) = self.withdraw_fee(who, call, info, len)?;13141315 let mut r = ValidTransaction::default();1316 // NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which1317 // will be a bit more than setting the priority to tip. For now, this is enough.1318 r.priority = fee.saturated_into::<TransactionPriority>();1319 Ok(r)1320 }13211322 fn pre_dispatch(1323 self,1324 who: &Self::AccountId,1325 call: &Self::Call,1326 info: &DispatchInfoOf<Self::Call>,1327 len: usize,1328 ) -> Result<Self::Pre, TransactionValidityError> {1329 let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1330 Ok((self.0, who.clone(), imbalance, fee))1331 }13321333 fn post_dispatch(1334 pre: Self::Pre,1335 info: &DispatchInfoOf<Self::Call>,1336 post_info: &PostDispatchInfoOf<Self::Call>,1337 len: usize,1338 _result: &DispatchResult,1339 ) -> Result<(), TransactionValidityError> {1340 let (tip, who, imbalance, fee) = pre;1341 if let Some(payed) = imbalance {1342 let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(1343 len as u32, info, post_info, tip,1344 );1345 let refund = fee.saturating_sub(actual_fee);1346 let actual_payment =1347 match <T as transaction_payment::Trait>::Currency::deposit_into_existing(1348 &who, refund,1349 ) {1350 Ok(refund_imbalance) => {1351 // The refund cannot be larger than the up front payed max weight.1352 // `PostDispatchInfo::calc_unspent` guards against such a case.1353 match payed.offset(refund_imbalance) {1354 Ok(actual_payment) => actual_payment,1355 Err(_) => return Err(InvalidTransaction::Payment.into()),1356 }1357 }1358 // We do not recreate the account using the refund. The up front payment1359 // is gone in that case.1360 Err(_) => payed,1361 };1362 let imbalances = actual_payment.split(tip);1363 <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(1364 Some(imbalances.0).into_iter().chain(Some(imbalances.1)),1365 );1366 }1367 Ok(())1368 }1369}