difftreelog
Chain runtime variable name changed
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 offchain_schema: Vec<u8>,101 pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender102 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship103}104105#[derive(Encode, Decode, Default, Clone, PartialEq)]106#[cfg_attr(feature = "std", derive(Debug))]107pub struct CollectionAdminsType<AccountId> {108 pub admin: AccountId,109 pub collection_id: u64,110}111112#[derive(Encode, Decode, Default, Clone, PartialEq)]113#[cfg_attr(feature = "std", derive(Debug))]114pub struct NftItemType<AccountId> {115 pub collection: u64,116 pub owner: AccountId,117 pub data: Vec<u8>,118}119120#[derive(Encode, Decode, Default, Clone, PartialEq)]121#[cfg_attr(feature = "std", derive(Debug))]122pub struct FungibleItemType<AccountId> {123 pub collection: u64,124 pub owner: AccountId,125 pub value: u128,126}127128#[derive(Encode, Decode, Default, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Debug))]130pub struct ReFungibleItemType<AccountId> {131 pub collection: u64,132 pub owner: Vec<Ownership<AccountId>>,133 pub data: Vec<u8>,134}135136#[derive(Encode, Decode, Default, Clone, PartialEq)]137#[cfg_attr(feature = "std", derive(Debug))]138pub struct ApprovePermissions<AccountId> {139 pub approved: AccountId,140 pub amount: u64,141}142143#[derive(Encode, Decode, Default, Clone, PartialEq)]144#[cfg_attr(feature = "std", derive(Debug))]145pub struct VestingItem<AccountId, Moment> {146 pub sender: AccountId,147 pub recipient: AccountId,148 pub collection_id: u64,149 pub item_id: u64,150 pub amount: u64,151 pub vesting_date: Moment,152}153154pub trait Trait: system::Trait {155 type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;156}157158decl_storage! {159 trait Store for Module<T: Trait> as Nft {160161 // Private members162 NextCollectionID: u64;163 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;164165 pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;166 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;167 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;168169 /// Balance owner per collection map170 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;171172 /// second parameter: item id + owner account id173 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;174175 /// Item collections176 pub NftItemList get(fn nft_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;177 pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;178 pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;179180 // Active vesting list181 // pub VestingList get(fn vesting): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => VestingItem<T::AccountId, T::Moment>;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 // Create collection of NFT with given parameters209 //210 // @param customDataSz size of custom data in each collection item211 // returns collection ID212 #[weight = 0]213 pub fn create_collection( origin,214 collection_name: Vec<u16>,215 collection_description: Vec<u16>,216 token_prefix: Vec<u8>,217 mode: CollectionMode) -> DispatchResult {218219 // Anyone can create a collection220 let who = ensure_signed(origin)?;221 let custom_data_size = match mode {222 CollectionMode::NFT(size) => size,223 CollectionMode::ReFungible(size, _) => size,224 _ => 0225 };226227 let decimal_points = match mode {228 CollectionMode::Fungible(points) => points,229 CollectionMode::ReFungible(_, points) => points,230 _ => 0231 };232233 // check params234 ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");235236 let mut name = collection_name.to_vec();237 name.push(0);238 ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");239240 let mut description = collection_description.to_vec();241 description.push(0);242 ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");243244 let mut prefix = token_prefix.to_vec();245 prefix.push(0);246 ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");247248 // Generate next collection ID249 let next_id = NextCollectionID::get()250 .checked_add(1)251 .expect("collection id error");252253 NextCollectionID::put(next_id);254255 // Create new collection256 let new_collection = CollectionType {257 owner: who.clone(),258 name: name,259 mode: mode.clone(),260 access: AccessMode::Normal,261 description: description,262 decimal_points: decimal_points,263 token_prefix: prefix,264 offchain_schema: Vec::new(),265 custom_data_size: custom_data_size,266 sponsor: T::AccountId::default(),267 unconfirmed_sponsor: T::AccountId::default(),268 };269270 // Add new collection to map271 <Collection<T>>::insert(next_id, new_collection);272273 // call event274 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));275276 Ok(())277 }278279 #[weight = 0]280 pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {281282 let sender = ensure_signed(origin)?;283 Self::check_owner_permissions(collection_id, sender)?;284285 // TODO Items remove286 <AddressTokens<T>>::remove_prefix(collection_id);287 <ApprovedList<T>>::remove_prefix(collection_id);288 <Balance<T>>::remove_prefix(collection_id);289 <ItemListIndex>::remove(collection_id);290 <AdminList<T>>::remove(collection_id);291 <Collection<T>>::remove(collection_id);292 <WhiteList<T>>::remove(collection_id);293294 Ok(())295 }296297 #[weight = 0]298 pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {299300 let sender = ensure_signed(origin)?;301 Self::check_owner_permissions(collection_id, sender)?;302 let mut target_collection = <Collection<T>>::get(collection_id);303 target_collection.owner = new_owner;304 <Collection<T>>::insert(collection_id, target_collection);305306 Ok(())307 }308309 #[weight = 0]310 pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {311312 let sender = ensure_signed(origin)?;313 Self::check_owner_or_admin_permissions(collection_id, sender)?;314 let mut admin_arr: Vec<T::AccountId> = Vec::new();315316 if <AdminList<T>>::contains_key(collection_id)317 {318 admin_arr = <AdminList<T>>::get(collection_id);319 ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");320 }321322 admin_arr.push(new_admin_id);323 <AdminList<T>>::insert(collection_id, admin_arr);324325 Ok(())326 }327328 #[weight = 0]329 pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {330331 let sender = ensure_signed(origin)?;332 Self::check_owner_or_admin_permissions(collection_id, sender)?;333334 if <AdminList<T>>::contains_key(collection_id)335 {336 let mut admin_arr = <AdminList<T>>::get(collection_id);337 admin_arr.retain(|i| *i != account_id);338 <AdminList<T>>::insert(collection_id, admin_arr);339 }340341 Ok(())342 }343344 #[weight = 0]345 pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {346347 let sender = ensure_signed(origin)?;348 ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");349350 let mut target_collection = <Collection<T>>::get(collection_id);351 ensure!(sender == target_collection.owner, "You do not own this collection");352353 target_collection.unconfirmed_sponsor = new_sponsor;354 <Collection<T>>::insert(collection_id, target_collection);355356 Ok(())357 }358359 #[weight = 0]360 pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {361362 let sender = ensure_signed(origin)?;363 ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");364365 let mut target_collection = <Collection<T>>::get(collection_id);366 ensure!(sender == target_collection.unconfirmed_sponsor, "This address is not set as sponsor, use setCollectionSponsor first");367368 target_collection.sponsor = target_collection.unconfirmed_sponsor;369 target_collection.unconfirmed_sponsor = T::AccountId::default();370 <Collection<T>>::insert(collection_id, target_collection);371372 Ok(())373 }374375 #[weight = 0]376 pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {377378 let sender = ensure_signed(origin)?;379 ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");380381 let mut target_collection = <Collection<T>>::get(collection_id);382 ensure!(sender == target_collection.owner, "You do not own this collection");383384 target_collection.sponsor = T::AccountId::default();385 <Collection<T>>::insert(collection_id, target_collection);386387 Ok(())388 }389390 #[weight = 0]391 pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {392393 let sender = ensure_signed(origin)?;394 let target_collection = <Collection<T>>::get(collection_id);395 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;396397 match target_collection.mode398 {399 CollectionMode::NFT(_) => {400401 // check size402 ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");403404 // Create nft item405 let item = NftItemType {406 collection: collection_id,407 owner: owner,408 data: properties,409 };410411 Self::add_nft_item(item)?;412413 },414 CollectionMode::Fungible(_) => {415416 // check size417 ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");418419 let item = FungibleItemType {420 collection: collection_id,421 owner: owner,422 value: (10 as u128).pow(target_collection.decimal_points)423 };424425 Self::add_fungible_item(item)?;426 },427 CollectionMode::ReFungible(_, _) => {428429 // check size430 ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");431432 let mut owner_list = Vec::new();433 let value = (10 as u128).pow(target_collection.decimal_points);434 owner_list.push(Ownership {owner: owner, fraction: value});435436 let item = ReFungibleItemType {437 collection: collection_id,438 owner: owner_list,439 data: properties440 };441442 Self::add_refungible_item(item)?;443 },444 _ => ()445 };446447 // call event448 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));449450 Ok(())451 }452453 #[weight = 0]454 pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {455456 let sender = ensure_signed(origin)?;457 let item_owner = Self::is_item_owner(sender.clone(), collection_id, item_id);458 if !item_owner459 {460 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;461 }462 let target_collection = <Collection<T>>::get(collection_id);463464 match target_collection.mode465 {466 CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,467 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection_id, item_id)?,468 CollectionMode::ReFungible(_, _) => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,469 _ => ()470 };471472 // call event473 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));474475 Ok(())476 }477478 #[weight = 0]479 pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {480481 let sender = ensure_signed(origin)?;482 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id), "Only item owner can call transfer method");483484 let target_collection = <Collection<T>>::get(collection_id);485486 // TODO: implement other modes487 match target_collection.mode488 {489 CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,490 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,491 CollectionMode::ReFungible(_, _) => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,492 _ => ()493 };494495 Ok(())496 }497498 #[weight = 0]499 pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {500501 let sender = ensure_signed(origin)?;502503 // amount param stub504 let amount = 100000000;505506 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id), "Only item owner can call transfer method");507508 let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));509 if list_exists {510511 let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));512 let item_contains = list.iter().any(|i| i.approved == approved);513514 if !item_contains {515 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });516 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);517 }518 } else {519520 let mut list = Vec::new();521 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });522 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);523 }524525 Ok(())526 }527528 #[weight = 0]529 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {530531 let sender = ensure_signed(origin)?;532 let approved_list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone()));533 if approved_list_exists534 {535 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));536 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());537 ensure!(opt_item.is_some(), "No approve found");538 ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");539540 // remove approve541 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))542 .into_iter().filter(|i| i.approved != sender.clone()).collect();543 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);544 }545 else546 {547 Self::check_owner_or_admin_permissions(collection_id, sender)?;548 }549550 let target_collection = <Collection<T>>::get(collection_id);551552 match target_collection.mode553 {554 CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,555 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,556 CollectionMode::ReFungible(_, _) => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,557 _ => ()558 };559560 Ok(())561 }562563 #[weight = 0]564 pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {565566 // let no_perm_mes = "You do not have permissions to modify this collection";567 // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);568 // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));569 // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);570571 // // on_nft_received call572573 // Self::transfer(origin, collection_id, item_id, new_owner)?;574575 Ok(())576 }577578 #[weight = 0]579 pub fn set_offchain_schema(580 origin,581 collection_id: u64,582 schema: Vec<u8>583 ) -> DispatchResult {584 let sender = ensure_signed(origin)?;585 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;586587 let mut target_collection = <Collection<T>>::get(collection_id);588 target_collection.offchain_schema = schema;589 <Collection<T>>::insert(collection_id, target_collection);590591 Ok(())592 }593 }594}595596impl<T: Trait> Module<T> {597 fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {598 let current_index = <ItemListIndex>::get(item.collection)599 .checked_add(1)600 .expect("Item list index id error");601 let itemcopy = item.clone();602 let owner = item.owner.clone();603 let value = item.value as u64;604605 Self::add_token_index(item.collection, current_index, owner.clone())?;606607 <ItemListIndex>::insert(item.collection, current_index);608 <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);609610 // Update balance611 let new_balance = <Balance<T>>::get(item.collection, owner.clone())612 .checked_add(value)613 .unwrap();614 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);615616 Ok(())617 }618619 fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {620 let current_index = <ItemListIndex>::get(item.collection)621 .checked_add(1)622 .expect("Item list index id error");623 let itemcopy = item.clone();624625 let value = item.owner.first().unwrap().fraction as u64;626 let owner = item.owner.first().unwrap().owner.clone();627628 Self::add_token_index(item.collection, current_index, owner.clone())?;629630 <ItemListIndex>::insert(item.collection, current_index);631 <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);632633 // Update balance634 let new_balance = <Balance<T>>::get(item.collection, owner.clone())635 .checked_add(value)636 .unwrap();637 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);638639 Ok(())640 }641642 fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {643 let current_index = <ItemListIndex>::get(item.collection)644 .checked_add(1)645 .expect("Item list index id error");646647 let item_owner = item.owner.clone();648 let collection_id = item.collection.clone();649 Self::add_token_index(collection_id, current_index, item.owner.clone())?;650651 <ItemListIndex>::insert(collection_id, current_index);652 <NftItemList<T>>::insert(collection_id, current_index, item);653654 // Update balance655 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())656 .checked_add(1)657 .unwrap();658 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);659660 Ok(())661 }662663 fn burn_refungible_item(664 collection_id: u64,665 item_id: u64,666 owner: T::AccountId,667 ) -> DispatchResult {668 ensure!(669 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),670 "Item does not exists"671 );672 let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);673 let item = collection674 .owner675 .iter()676 .filter(|&i| i.owner == owner)677 .next()678 .unwrap();679 Self::remove_token_index(collection_id, item_id, owner.clone())?;680681 // remove approve list682 <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));683684 // update balance685 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())686 .checked_sub(item.fraction as u64)687 .unwrap();688 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);689690 <ReFungibleItemList<T>>::remove(collection_id, item_id);691692 Ok(())693 }694695 fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {696 ensure!(697 <NftItemList<T>>::contains_key(collection_id, item_id),698 "Item does not exists"699 );700 let item = <NftItemList<T>>::get(collection_id, item_id);701 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;702703 // remove approve list704 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));705706 // update balance707 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())708 .checked_sub(1)709 .unwrap();710 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);711 <NftItemList<T>>::remove(collection_id, item_id);712713 Ok(())714 }715716 fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {717 ensure!(718 <FungibleItemList<T>>::contains_key(collection_id, item_id),719 "Item does not exists"720 );721 let item = <FungibleItemList<T>>::get(collection_id, item_id);722 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;723724 // remove approve list725 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));726727 // update balance728 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())729 .checked_sub(item.value as u64)730 .unwrap();731 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);732733 <FungibleItemList<T>>::remove(collection_id, item_id);734735 Ok(())736 }737738 fn collection_exists(collection_id: u64) -> DispatchResult {739 ensure!(740 <Collection<T>>::contains_key(collection_id),741 "This collection does not exist"742 );743 Ok(())744 }745746 fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {747 Self::collection_exists(collection_id)?;748749 let target_collection = <Collection<T>>::get(collection_id);750 ensure!(751 subject == target_collection.owner,752 "You do not own this collection"753 );754755 Ok(())756 }757758 fn check_owner_or_admin_permissions(759 collection_id: u64,760 subject: T::AccountId,761 ) -> DispatchResult {762 Self::collection_exists(collection_id)?;763764 let target_collection = <Collection<T>>::get(collection_id);765 let is_owner = subject == target_collection.owner;766767 let no_perm_mes = "You do not have permissions to modify this collection";768 let exists = <AdminList<T>>::contains_key(collection_id);769770 if !is_owner {771 ensure!(exists, no_perm_mes);772 ensure!(773 <AdminList<T>>::get(collection_id).contains(&subject),774 no_perm_mes775 );776 }777 Ok(())778 }779780 fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {781 let target_collection = <Collection<T>>::get(collection_id);782783 match target_collection.mode {784 CollectionMode::NFT(_) => {785 <NftItemList<T>>::get(collection_id, item_id).owner == subject786 }787 CollectionMode::Fungible(_) => {788 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject789 }790 CollectionMode::ReFungible(_, _) => {791 <ReFungibleItemList<T>>::get(collection_id, item_id)792 .owner793 .iter()794 .any(|i| i.owner == subject)795 }796 CollectionMode::Invalid => false,797 }798 }799800 fn transfer_fungible(801 collection_id: u64,802 item_id: u64,803 value: u64,804 owner: T::AccountId,805 new_owner: T::AccountId,806 ) -> DispatchResult {807 let full_item = <FungibleItemList<T>>::get(collection_id, item_id);808 let amount = full_item.value;809810 ensure!(amount >= value.into(), "Item balance not enouth");811812 // update balance813 let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())814 .checked_sub(value)815 .unwrap();816 <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);817818 let mut new_owner_account_id = 0;819 let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());820 if new_owner_items.len() > 0 {821 new_owner_account_id = new_owner_items[0];822 }823824 let val64 = value.into();825826 // transfer827 if amount == val64 && new_owner_account_id == 0 {828 // change owner829 // new owner do not have account830 let mut new_full_item = full_item.clone();831 new_full_item.owner = new_owner.clone();832 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);833834 // update balance835 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())836 .checked_add(value)837 .unwrap();838 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);839840 // update index collection841 Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;842 } else {843 let mut new_full_item = full_item.clone();844 new_full_item.value -= val64;845846 // separate amount847 if new_owner_account_id > 0 {848 // new owner has account849 let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);850 item.value += val64;851852 // update balance853 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())854 .checked_add(value)855 .unwrap();856 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);857858 <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);859 } else {860 // new owner do not have account861 let item = FungibleItemType {862 collection: collection_id,863 owner: new_owner.clone(),864 value: val64,865 };866867 Self::add_fungible_item(item)?;868 }869870 if amount == val64 {871 Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;872873 // remove approve list874 <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));875 <FungibleItemList<T>>::remove(collection_id, item_id);876 }877878 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);879 }880881 Ok(())882 }883884 fn transfer_refungible(885 collection_id: u64,886 item_id: u64,887 value: u64,888 owner: T::AccountId,889 new_owner: T::AccountId,890 ) -> DispatchResult {891 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);892 let item = full_item893 .owner894 .iter()895 .filter(|i| i.owner == owner)896 .next()897 .unwrap();898 let amount = item.fraction;899900 ensure!(amount >= value.into(), "Item balance not enouth");901902 // update balance903 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())904 .checked_sub(value)905 .unwrap();906 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);907908 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())909 .checked_add(value)910 .unwrap();911 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);912913 let old_owner = item.owner.clone();914 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);915 let val64 = value.into();916917 // transfer918 if amount == val64 && !new_owner_has_account {919 // change owner920 // new owner do not have account921 let mut new_full_item = full_item.clone();922 new_full_item923 .owner924 .iter_mut()925 .find(|i| i.owner == owner)926 .unwrap()927 .owner = new_owner.clone();928 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);929930 // update index collection931 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;932 } else {933 let mut new_full_item = full_item.clone();934 new_full_item935 .owner936 .iter_mut()937 .find(|i| i.owner == owner)938 .unwrap()939 .fraction -= val64;940941 // separate amount942 if new_owner_has_account {943 // new owner has account944 new_full_item945 .owner946 .iter_mut()947 .find(|i| i.owner == new_owner)948 .unwrap()949 .fraction += val64;950 } else {951 // new owner do not have account952 new_full_item.owner.push(Ownership {953 owner: new_owner.clone(),954 fraction: val64,955 });956 Self::add_token_index(collection_id, item_id, new_owner.clone())?;957 }958959 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);960 }961962 Ok(())963 }964965 fn transfer_nft(966 collection_id: u64,967 item_id: u64,968 sender: T::AccountId,969 new_owner: T::AccountId,970 ) -> DispatchResult {971 let mut item = <NftItemList<T>>::get(collection_id, item_id);972973 ensure!(974 sender == item.owner,975 "sender parameter and item owner must be equal"976 );977978 // update balance979 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())980 .checked_sub(1)981 .unwrap();982 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);983984 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())985 .checked_add(1)986 .unwrap();987 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);988989 // change owner990 let old_owner = item.owner.clone();991 item.owner = new_owner.clone();992 <NftItemList<T>>::insert(collection_id, item_id, item);993994 // update index collection995 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;996997 // reset approved list998 <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));999 Ok(())1000 }10011002 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {1003 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1004 if list_exists {1005 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1006 let item_contains = list.contains(&item_index.clone());10071008 if !item_contains {1009 list.push(item_index.clone());1010 }10111012 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);1013 } else {1014 let mut itm = Vec::new();1015 itm.push(item_index.clone());1016 <AddressTokens<T>>::insert(collection_id, owner, itm);1017 }10181019 Ok(())1020 }10211022 fn remove_token_index(1023 collection_id: u64,1024 item_index: u64,1025 owner: T::AccountId,1026 ) -> DispatchResult {1027 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1028 if list_exists {1029 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());1030 let item_contains = list.contains(&item_index.clone());10311032 if item_contains {1033 list.retain(|&item| item != item_index);1034 <AddressTokens<T>>::insert(collection_id, owner, list);1035 }1036 }10371038 Ok(())1039 }10401041 fn move_token_index(1042 collection_id: u64,1043 item_index: u64,1044 old_owner: T::AccountId,1045 new_owner: T::AccountId,1046 ) -> DispatchResult {1047 Self::remove_token_index(collection_id, item_index, old_owner)?;1048 Self::add_token_index(collection_id, item_index, new_owner)?;10491050 Ok(())1051 }1052}10531054////////////////////////////////////////////////////////////////////////////////////////////////////1055// Economic models10561057/// Fee multiplier.1058pub type Multiplier = FixedU128;10591060type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1061 <T as system::Trait>::AccountId,1062>>::Balance;1063type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1064 <T as system::Trait>::AccountId,1065>>::NegativeImbalance;10661067/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1068/// in the queue.1069#[derive(Encode, Decode, Clone, Eq, PartialEq)]1070pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(1071 #[codec(compact)] BalanceOf<T>,1072);10731074impl<T: Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug1075 for ChargeTransactionPayment<T>1076{1077 #[cfg(feature = "std")]1078 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1079 write!(f, "ChargeTransactionPayment<{:?}>", self.0)1080 }1081 #[cfg(not(feature = "std"))]1082 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1083 Ok(())1084 }1085}10861087impl<T: Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T>1088where1089 T::Call:1090 Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1091 BalanceOf<T>: Send + Sync + FixedPointOperand,1092{1093 /// utility constructor. Used only in client/factory code.1094 pub fn from(fee: BalanceOf<T>) -> Self {1095 Self(fee)1096 }10971098 pub fn traditional_fee(1099 len: usize,1100 info: &DispatchInfoOf<T::Call>,1101 tip: BalanceOf<T>,1102 ) -> BalanceOf<T>1103 where1104 T::Call: Dispatchable<Info = DispatchInfo>,1105 {1106 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1107 }11081109 fn withdraw_fee(1110 &self,1111 who: &T::AccountId,1112 call: &T::Call,1113 info: &DispatchInfoOf<T::Call>,1114 len: usize,1115 ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1116 let tip = self.0;11171118 // Set fee based on call type. Creating collection costs 1 Unique.1119 // All other transactions have traditional fees so far1120 let fee = match call.is_sub_type() {1121 Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1122 _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes1123 // _ => <BalanceOf<T>>::from(100)1124 };11251126 // Determine who is paying transaction fee based on ecnomic model1127 // Parse call to extract collection ID and access collection sponsor1128 let sponsor: T::AccountId = match call.is_sub_type() {1129 Some(Call::create_item(collection_id, _properties, _owner)) => {1130 <Collection<T>>::get(collection_id).sponsor1131 }1132 Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1133 <Collection<T>>::get(collection_id).sponsor1134 }11351136 _ => T::AccountId::default(),1137 };11381139 let mut who_pays_fee: T::AccountId = sponsor.clone();1140 if sponsor == T::AccountId::default() {1141 who_pays_fee = who.clone();1142 }11431144 // Only mess with balances if fee is not zero.1145 if fee.is_zero() {1146 return Ok((fee, None));1147 }11481149 match <T as transaction_payment::Trait>::Currency::withdraw(1150 &who_pays_fee,1151 fee,1152 if tip.is_zero() {1153 WithdrawReason::TransactionPayment.into()1154 } else {1155 WithdrawReason::TransactionPayment | WithdrawReason::Tip1156 },1157 ExistenceRequirement::KeepAlive,1158 ) {1159 Ok(imbalance) => Ok((fee, Some(imbalance))),1160 Err(_) => Err(InvalidTransaction::Payment.into()),1161 }1162 }1163}11641165impl<T: Trait + transaction_payment::Trait + Send + Sync> SignedExtension1166 for ChargeTransactionPayment<T>1167where1168 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1169 T::Call:1170 Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,1171{1172 const IDENTIFIER: &'static str = "ChargeTransactionPayment";1173 type AccountId = T::AccountId;1174 type Call = T::Call;1175 type AdditionalSigned = ();1176 type Pre = (1177 BalanceOf<T>,1178 Self::AccountId,1179 Option<NegativeImbalanceOf<T>>,1180 BalanceOf<T>,1181 );1182 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {1183 Ok(())1184 }11851186 fn validate(1187 &self,1188 who: &Self::AccountId,1189 call: &Self::Call,1190 info: &DispatchInfoOf<Self::Call>,1191 len: usize,1192 ) -> TransactionValidity {1193 let (fee, _) = self.withdraw_fee(who, call, info, len)?;11941195 let mut r = ValidTransaction::default();1196 // NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which1197 // will be a bit more than setting the priority to tip. For now, this is enough.1198 r.priority = fee.saturated_into::<TransactionPriority>();1199 Ok(r)1200 }12011202 fn pre_dispatch(1203 self,1204 who: &Self::AccountId,1205 call: &Self::Call,1206 info: &DispatchInfoOf<Self::Call>,1207 len: usize,1208 ) -> Result<Self::Pre, TransactionValidityError> {1209 let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1210 Ok((self.0, who.clone(), imbalance, fee))1211 }12121213 fn post_dispatch(1214 pre: Self::Pre,1215 info: &DispatchInfoOf<Self::Call>,1216 post_info: &PostDispatchInfoOf<Self::Call>,1217 len: usize,1218 _result: &DispatchResult,1219 ) -> Result<(), TransactionValidityError> {1220 let (tip, who, imbalance, fee) = pre;1221 if let Some(payed) = imbalance {1222 let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(1223 len as u32, info, post_info, tip,1224 );1225 let refund = fee.saturating_sub(actual_fee);1226 let actual_payment =1227 match <T as transaction_payment::Trait>::Currency::deposit_into_existing(1228 &who, refund,1229 ) {1230 Ok(refund_imbalance) => {1231 // The refund cannot be larger than the up front payed max weight.1232 // `PostDispatchInfo::calc_unspent` guards against such a case.1233 match payed.offset(refund_imbalance) {1234 Ok(actual_payment) => actual_payment,1235 Err(_) => return Err(InvalidTransaction::Payment.into()),1236 }1237 }1238 // We do not recreate the account using the refund. The up front payment1239 // is gone in that case.1240 Err(_) => payed,1241 };1242 let imbalances = actual_payment.split(tip);1243 <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(1244 Some(imbalances.0).into_iter().chain(Some(imbalances.1)),1245 );1246 }1247 Ok(())1248 }1249}