git.delta.rocks / unique-network / refs/commits / e67fafd19a27

1#![cfg_attr(not(feature = "std"), no_std)]23use codec::{Decode, Encode};4/// A FRAME pallet template with necessary imports56/// Feel free to remove or edit this file as needed.7/// If you change the name of this file, make sure to update its references in runtime/src/lib.rs8/// If you remove this file, you can remove those references910/// For more guidance on Substrate FRAME, see the example pallet11/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs12use frame_support::{decl_event, decl_module, decl_storage, dispatch::DispatchResult, ensure};13use frame_system::{self as system, ensure_signed};14use sp_runtime::sp_std::prelude::Vec;1516#[cfg(test)]17mod mock;1819#[cfg(test)]20mod tests;2122#[derive(Encode, Decode, Default, Clone, PartialEq)]23#[cfg_attr(feature = "std", derive(Debug))]24pub struct CollectionType<AccountId> {25    pub owner: AccountId,26    pub next_item_id: u64,27    pub name: Vec<u16>, // 64 include null escape char28    pub description: Vec<u16>, // 256 include null escape char29    pub token_prefix: Vec<u8>, // 16 include null escape char30    pub custom_data_size: u32,31}3233#[derive(Encode, Decode, Default, Clone, PartialEq)]34#[cfg_attr(feature = "std", derive(Debug))]35pub struct CollectionAdminsType<AccountId> {36    pub admin: AccountId,37    pub collection_id: u64,38}3940#[derive(Encode, Decode, Default, Clone, PartialEq)]41#[cfg_attr(feature = "std", derive(Debug))]42pub struct NftItemType<AccountId> {43    pub collection: u64,44    pub owner: AccountId,45    pub data: Vec<u8>,46}4748/// The pallet's configuration trait.49pub trait Trait: system::Trait {50    // Add other types and constants required to configure this pallet.5152    /// The overarching event type.53    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;54}5556// This pallet's storage items.57decl_storage! {58    // It is important to update your storage name so that your pallet's59    // storage items are isolated from other pallets.60    trait Store for Module<T: Trait> as Nft {6162        /// Next available collection ID63        pub NextCollectionID get(fn next_collection_id): u64;64        pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;65        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;6667        /// Balance owner per collection map68        pub Balance get(fn balance_count): map hasher(blake2_128_concat) (u64, T::AccountId) => u64;69        pub ApprovedList get(fn approved): map hasher(blake2_128_concat) (u64, u64) => Vec<T::AccountId>;7071        pub ItemList get(fn item_id): map hasher(blake2_128_concat) (u64, u64) => NftItemType<T::AccountId>;72        pub ItemListIndex get(fn item_index): map hasher(blake2_128_concat) u64 => u64;7374        pub AddressTokens get(fn address_tokens): map hasher(blake2_128_concat) (u64, T::AccountId) => Vec<u64>;7576    }77}7879// The pallet's events80decl_event!(81    pub enum Event<T>82    where83        AccountId = <T as system::Trait>::AccountId,84    {85        Created(u64, AccountId),86        ItemCreated(u64),87        ItemDestroyed(u64, u64),88    }89);9091// The pallet's dispatchable functions.92decl_module! {93    /// The module declaration.94    pub struct Module<T: Trait> for enum Call where origin: T::Origin {9596        // Initializing events97        // this is needed only if you are using events in your pallet98        fn deposit_event() = default;99100        // Create collection of NFT with given parameters101        //102        // @param customDataSz size of custom data in each collection item103        // returns collection ID104105        // Create collection of NFT with given parameters106        //107        // @param customDataSz size of custom data in each collection item108        // returns collection ID109        #[weight = 0]110        pub fn create_collection(   origin, 111                                    collection_name: Vec<u16>, 112                                    collection_description: Vec<u16>, 113                                    token_prefix: Vec<u8>, 114                                    custom_data_sz: u32) -> DispatchResult {115116            // Anyone can create a collection117            let who = ensure_signed(origin)?;118119            // check params 120            let mut name = collection_name.to_vec();121            name.push(0);122            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");123124            let mut description = collection_description.to_vec();125            description.push(0);126            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");127128            let mut prefix = token_prefix.to_vec();129            prefix.push(0);130            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");131132            // Generate next collection ID133            let next_id = NextCollectionID::get()134                .checked_add(1)135                .expect("collection id error");136137            NextCollectionID::put(next_id);138139            // Create new collection140            let new_collection = CollectionType {141                owner: who.clone(),142                name: name,143                description: description,144                token_prefix: prefix,145                next_item_id: next_id,146                custom_data_size: custom_data_sz,147            };148149            // Add new collection to map150            <Collection<T>>::insert(next_id, new_collection);151152            // call event153            Self::deposit_event(RawEvent::Created(next_id, who.clone()));154155            Ok(())156        }157158        #[weight = 0]159        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {160161            let sender = ensure_signed(origin)?;162            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");163164            let owner = <Collection<T>>::get(collection_id).owner;165            ensure!(sender == owner, "You do not own this collection");166            <Collection<T>>::remove(collection_id);167168            Ok(())169        }170171        #[weight = 0]172        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {173174            let sender = ensure_signed(origin)?;175            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");176177            let mut target_collection = <Collection<T>>::get(collection_id);178            ensure!(sender == target_collection.owner, "You do not own this collection");179180            target_collection.owner = new_owner;181            <Collection<T>>::insert(collection_id, target_collection);182183            Ok(())184        }185186        #[weight = 0]187        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {188189            let sender = ensure_signed(origin)?;190            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");191192            let target_collection = <Collection<T>>::get(collection_id);193            let is_owner = sender == target_collection.owner;194195            let no_perm_mes = "You do not have permissions to modify this collection";196            let exists = <AdminList<T>>::contains_key(collection_id);197198            if !is_owner199            {200                 ensure!(exists, no_perm_mes);201                 ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);202            }203204            let mut admin_arr: Vec<T::AccountId> = Vec::new();205            if exists206            {207                admin_arr = <AdminList<T>>::get(collection_id);208                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");209            }210211            admin_arr.push(new_admin_id);212            <AdminList<T>>::insert(collection_id, admin_arr);213214            Ok(())215        }216217        #[weight = 0]218        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {219220            let sender = ensure_signed(origin)?;221            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");222223            let target_collection = <Collection<T>>::get(collection_id);224            let is_owner = sender == target_collection.owner;225226            let no_perm_mes = "You do not have permissions to modify this collection";227            let exists = <AdminList<T>>::contains_key(collection_id);228229            if !is_owner230            {231                ensure!(exists, no_perm_mes);232                ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);233            }234235            if exists236            {237                let mut admin_arr = <AdminList<T>>::get(collection_id);238                admin_arr.retain(|i| *i != account_id);239                <AdminList<T>>::insert(collection_id, admin_arr);240            }241242            Ok(())243        }244245        #[weight = 0]246        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>) -> DispatchResult {247248            let sender = ensure_signed(origin)?;249            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");250251            let target_collection = <Collection<T>>::get(collection_id);252            ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");253            let is_owner = sender == target_collection.owner;254255            let no_perm_mes = "You do not have permissions to modify this collection";256            let exists = <AdminList<T>>::contains_key(collection_id);257258            if !is_owner259            {260                ensure!(exists, no_perm_mes);261                ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);262            }263264            let new_balance = <Balance<T>>::get((collection_id, sender.clone())) + 1;265            <Balance<T>>::insert((collection_id, sender.clone()), new_balance);266267            // Create new item268            let new_item = NftItemType {269                collection: collection_id,270                owner: sender,271                data: properties,272            };273274275            let current_index = <ItemListIndex>::get(collection_id)276                .checked_add(1)277                .expect("Item list index id error");278279            Self::add_token_index(collection_id, current_index, new_item.owner.clone())?;280281            <ItemListIndex>::insert(collection_id, current_index);282            <ItemList<T>>::insert((collection_id, current_index), new_item);283284            // call event285            Self::deposit_event(RawEvent::ItemCreated(collection_id));286287            Ok(())288        }289290        #[weight = 0]291        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {292293            let sender = ensure_signed(origin)?;294            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");295296            let target_collection = <Collection<T>>::get(collection_id);297            let is_owner = sender == target_collection.owner;298299            ensure!(<ItemList<T>>::contains_key((collection_id, item_id)), "Item does not exists");300            let item = <ItemList<T>>::get((collection_id, item_id));301302            if !is_owner303            {304                // check if item owner305                if item.owner != sender306                {307                    let no_perm_mes = "You do not have permissions to modify this collection";308309                    ensure!(<AdminList<T>>::contains_key(collection_id), no_perm_mes);310                    ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);311                }312            }313            <ItemList<T>>::remove((collection_id, item_id));314315            Self::remove_token_index(collection_id, item_id, item.owner.clone())?;316317            // update balance318            let new_balance = <Balance<T>>::get((collection_id, item.owner.clone())) - 1;319            <Balance<T>>::insert((collection_id, item.owner.clone()), new_balance);320321            // call event322            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));323324            Ok(())325        }326327        #[weight = 0]328        pub fn transfer(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {329330            let sender = ensure_signed(origin)?;331            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");332333            let target_collection = <Collection<T>>::get(collection_id);334            let is_owner = sender == target_collection.owner;335336            ensure!(<ItemList<T>>::contains_key((collection_id, item_id)), "Item does not exists");337            let mut item = <ItemList<T>>::get((collection_id, item_id));338339            if !is_owner340            {341                // check if item owner342                if item.owner != sender343                {344                    let no_perm_mes = "You do not have permissions to modify this collection";345346                    ensure!(<AdminList<T>>::contains_key(collection_id), no_perm_mes);347                    ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);348                }349            }350            <ItemList<T>>::remove((collection_id, item_id));351352            // update balance353            let balance_old_owner = <Balance<T>>::get((collection_id, item.owner.clone())) - 1;354            <Balance<T>>::insert((collection_id, item.owner.clone()), balance_old_owner);355356            let balance_new_owner = <Balance<T>>::get((collection_id, new_owner.clone())) + 1;357            <Balance<T>>::insert((collection_id, new_owner.clone()), balance_new_owner);358359            // change owner360            let old_owner = item.owner.clone();361            item.owner = new_owner.clone();362            <ItemList<T>>::insert((collection_id, item_id), item);363364            // update index collection365            Self::move_token_index(collection_id, item_id, old_owner, new_owner.clone())?;366367            // reset approved list368            let itm: Vec<T::AccountId> = Vec::new();369            <ApprovedList<T>>::insert((collection_id, item_id), itm);370371            Ok(())372        }373374        #[weight = 0]375        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {376377            let sender = ensure_signed(origin)?;378            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");379380            let target_collection = <Collection<T>>::get(collection_id);381            let is_owner = sender == target_collection.owner;382383            ensure!(<ItemList<T>>::contains_key((collection_id, item_id)), "Item does not exists");384            let item = <ItemList<T>>::get((collection_id, item_id));385386            if !is_owner387            {388                // check if item owner389                if item.owner != sender390                {391                    let no_perm_mes = "You do not have permissions to modify this collection";392393                    ensure!(<AdminList<T>>::contains_key(collection_id), no_perm_mes);394                    ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);395                }396            }397398            let list_exists = <ApprovedList<T>>::contains_key((collection_id, item_id));399            if list_exists {400401                let mut list = <ApprovedList<T>>::get((collection_id, item_id));402                let item_contains = list.contains(&approved.clone());403404                if !item_contains {405                    list.push(approved.clone());406                }407            } else {408409                let mut itm = Vec::new();410                itm.push(approved.clone());411                <ApprovedList<T>>::insert((collection_id, item_id), itm);412            }413414            Ok(())415        }416417        #[weight = 0]418        pub fn transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {419420            let no_perm_mes = "You do not have permissions to modify this collection";421            ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);422            let list_itm = <ApprovedList<T>>::get((collection_id, item_id));423            ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);424425            Self::transfer(origin, collection_id, item_id, new_owner)?;426427            Ok(())428        }429430        #[weight = 0]431        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {432433            let no_perm_mes = "You do not have permissions to modify this collection";434            ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);435            let list_itm = <ApprovedList<T>>::get((collection_id, item_id));436            ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);437438            // on_nft_received  call439440            Self::transfer(origin, collection_id, item_id, new_owner)?;441442            Ok(())443        }444    }445}446447448impl<T: Trait> Module<T> {449    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {450        451        let list_exists = <AddressTokens<T>>::contains_key((collection_id, owner.clone()));452        if list_exists {453454            let mut list = <AddressTokens<T>>::get((collection_id, owner.clone()));455            let item_contains = list.contains(&item_index.clone());456457            if !item_contains {458                list.push(item_index.clone());459            }460461            <AddressTokens<T>>::insert((collection_id, owner.clone()), list);462463        } else {464465            let mut itm = Vec::new();466            itm.push(item_index.clone());467            <AddressTokens<T>>::insert((collection_id, owner), itm);468        }469470        Ok(())471    }472473    fn remove_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {474        475        let list_exists = <AddressTokens<T>>::contains_key((collection_id, owner.clone()));476        if list_exists {477478            let mut list = <AddressTokens<T>>::get((collection_id, owner.clone()));479            let item_contains = list.contains(&item_index.clone());480481            if item_contains {482                list.retain(|&item| item != item_index);483                <AddressTokens<T>>::insert((collection_id, owner), list);484            }485        }486487        Ok(())488    }489490    fn move_token_index(collection_id: u64, item_index: u64, old_owner: T::AccountId, new_owner: T::AccountId) -> DispatchResult {491        492        Self::remove_token_index(collection_id, item_index, old_owner)?;493        Self::add_token_index(collection_id, item_index, new_owner)?;494        495        Ok(())496    }497}