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

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>;75    }76}7778// The pallet's events79decl_event!(80    pub enum Event<T>81    where82        AccountId = <T as system::Trait>::AccountId,83    {84        Created(u64, AccountId),85        ItemCreated(u64),86        ItemDestroyed(u64, u64),87    }88);8990// The pallet's dispatchable functions.91decl_module! {92    /// The module declaration.93    pub struct Module<T: Trait> for enum Call where origin: T::Origin {9495        // Initializing events96        // this is needed only if you are using events in your pallet97        fn deposit_event() = default;9899        // Create collection of NFT with given parameters100        //101        // @param customDataSz size of custom data in each collection item102        // returns collection ID103        #[weight = 0]104        pub fn create_collection(   origin,105                                    collection_name: Vec<u16>,106                                    collection_description: Vec<u16>,107                                    token_prefix: Vec<u8>,108                                    custom_data_sz: u32) -> DispatchResult {109110            // Anyone can create a collection111            let who = ensure_signed(origin)?;112113            // check params114            let mut name = collection_name.to_vec();115            name.push(0);116            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");117118            let mut description = collection_description.to_vec();119            description.push(0);120            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");121122            let mut prefix = token_prefix.to_vec();123            prefix.push(0);124            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");125126            // Generate next collection ID127            let next_id = NextCollectionID::get()128                .checked_add(1)129                .expect("collection id error");130131            NextCollectionID::put(next_id);132133            // Create new collection134            let new_collection = CollectionType {135                owner: who.clone(),136                name: name,137                description: description,138                token_prefix: prefix,139                next_item_id: next_id,140                custom_data_size: custom_data_sz,141            };142143            // Add new collection to map144            <Collection<T>>::insert(next_id, new_collection);145146            // call event147            Self::deposit_event(RawEvent::Created(next_id, who.clone()));148149            Ok(())150        }151152        #[weight = 0]153        pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {154155            let sender = ensure_signed(origin)?;156            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");157158            let owner = <Collection<T>>::get(collection_id).owner;159            ensure!(sender == owner, "You do not own this collection");160            <Collection<T>>::remove(collection_id);161162            Ok(())163        }164165        #[weight = 0]166        pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {167168            let sender = ensure_signed(origin)?;169            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");170171            let mut target_collection = <Collection<T>>::get(collection_id);172            ensure!(sender == target_collection.owner, "You do not own this collection");173174            target_collection.owner = new_owner;175            <Collection<T>>::insert(collection_id, target_collection);176177            Ok(())178        }179180        #[weight = 0]181        pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {182183            let sender = ensure_signed(origin)?;184            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");185186            let target_collection = <Collection<T>>::get(collection_id);187            let is_owner = sender == target_collection.owner;188189            let no_perm_mes = "You do not have permissions to modify this collection";190            let exists = <AdminList<T>>::contains_key(collection_id);191192            if !is_owner193            {194                 ensure!(exists, no_perm_mes);195                 ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);196            }197198            let mut admin_arr: Vec<T::AccountId> = Vec::new();199            if exists200            {201                admin_arr = <AdminList<T>>::get(collection_id);202                ensure!(!admin_arr.contains(&new_admin_id), "Account already has admin role");203            }204205            admin_arr.push(new_admin_id);206            <AdminList<T>>::insert(collection_id, admin_arr);207208            Ok(())209        }210211        #[weight = 0]212        pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {213214            let sender = ensure_signed(origin)?;215            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");216217            let target_collection = <Collection<T>>::get(collection_id);218            let is_owner = sender == target_collection.owner;219220            let no_perm_mes = "You do not have permissions to modify this collection";221            let exists = <AdminList<T>>::contains_key(collection_id);222223            if !is_owner224            {225                ensure!(exists, no_perm_mes);226                ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);227            }228229            if exists230            {231                let mut admin_arr = <AdminList<T>>::get(collection_id);232                admin_arr.retain(|i| *i != account_id);233                <AdminList<T>>::insert(collection_id, admin_arr);234            }235236            Ok(())237        }238239        #[weight = 0]240        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>) -> DispatchResult {241242            let sender = ensure_signed(origin)?;243            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");244245            let target_collection = <Collection<T>>::get(collection_id);246            ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");247            let is_owner = sender == target_collection.owner;248249            let no_perm_mes = "You do not have permissions to modify this collection";250            let exists = <AdminList<T>>::contains_key(collection_id);251252            if !is_owner253            {254                ensure!(exists, no_perm_mes);255                ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);256            }257258            let new_balance = <Balance<T>>::get((collection_id, sender.clone())) + 1;259            <Balance<T>>::insert((collection_id, sender.clone()), new_balance);260261            // Create new item262            let new_item = NftItemType {263                collection: collection_id,264                owner: sender,265                data: properties,266            };267268269            let current_index = <ItemListIndex>::get(collection_id)270                .checked_add(1)271                .expect("Item list index id error");272273            Self::add_token_index(collection_id, current_index, new_item.owner.clone())?;274275            <ItemListIndex>::insert(collection_id, current_index);276            <ItemList<T>>::insert((collection_id, current_index), new_item);277278            // call event279            Self::deposit_event(RawEvent::ItemCreated(collection_id));280281            Ok(())282        }283284        #[weight = 0]285        pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {286287            let sender = ensure_signed(origin)?;288            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");289290            let target_collection = <Collection<T>>::get(collection_id);291            let is_owner = sender == target_collection.owner;292293            ensure!(<ItemList<T>>::contains_key((collection_id, item_id)), "Item does not exists");294            let item = <ItemList<T>>::get((collection_id, item_id));295296            if !is_owner297            {298                // check if item owner299                if item.owner != sender300                {301                    let no_perm_mes = "You do not have permissions to modify this collection";302303                    ensure!(<AdminList<T>>::contains_key(collection_id), no_perm_mes);304                    ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);305                }306            }307            <ItemList<T>>::remove((collection_id, item_id));308309            Self::remove_token_index(collection_id, item_id, item.owner.clone())?;310311            // update balance312            let new_balance = <Balance<T>>::get((collection_id, item.owner.clone())) - 1;313            <Balance<T>>::insert((collection_id, item.owner.clone()), new_balance);314315            // call event316            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));317318            Ok(())319        }320321        #[weight = 0]322        pub fn transfer(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {323324            let sender = ensure_signed(origin)?;325            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");326327            let target_collection = <Collection<T>>::get(collection_id);328            let is_owner = sender == target_collection.owner;329330            ensure!(<ItemList<T>>::contains_key((collection_id, item_id)), "Item does not exists");331            let mut item = <ItemList<T>>::get((collection_id, item_id));332333            if !is_owner334            {335                // check if item owner336                if item.owner != sender337                {338                    let no_perm_mes = "You do not have permissions to modify this collection";339340                    ensure!(<AdminList<T>>::contains_key(collection_id), no_perm_mes);341                    ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);342                }343            }344            <ItemList<T>>::remove((collection_id, item_id));345346            // update balance347            let balance_old_owner = <Balance<T>>::get((collection_id, item.owner.clone())) - 1;348            <Balance<T>>::insert((collection_id, item.owner.clone()), balance_old_owner);349350            let balance_new_owner = <Balance<T>>::get((collection_id, new_owner.clone())) + 1;351            <Balance<T>>::insert((collection_id, new_owner.clone()), balance_new_owner);352353            // change owner354            let old_owner = item.owner.clone();355            item.owner = new_owner.clone();356            <ItemList<T>>::insert((collection_id, item_id), item);357358            // update index collection359            Self::move_token_index(collection_id, item_id, old_owner, new_owner.clone())?;360361            // reset approved list362            let itm: Vec<T::AccountId> = Vec::new();363            <ApprovedList<T>>::insert((collection_id, item_id), itm);364365            Ok(())366        }367368        #[weight = 0]369        pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {370371            let sender = ensure_signed(origin)?;372            ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");373374            let target_collection = <Collection<T>>::get(collection_id);375            let is_owner = sender == target_collection.owner;376377            ensure!(<ItemList<T>>::contains_key((collection_id, item_id)), "Item does not exists");378            let item = <ItemList<T>>::get((collection_id, item_id));379380            if !is_owner381            {382                // check if item owner383                if item.owner != sender384                {385                    let no_perm_mes = "You do not have permissions to modify this collection";386387                    ensure!(<AdminList<T>>::contains_key(collection_id), no_perm_mes);388                    ensure!(<AdminList<T>>::get(collection_id).contains(&sender), no_perm_mes);389                }390            }391392            let list_exists = <ApprovedList<T>>::contains_key((collection_id, item_id));393            if list_exists {394395                let mut list = <ApprovedList<T>>::get((collection_id, item_id));396                let item_contains = list.contains(&approved.clone());397398                if !item_contains {399                    list.push(approved.clone());400                }401            } else {402403                let mut itm = Vec::new();404                itm.push(approved.clone());405                <ApprovedList<T>>::insert((collection_id, item_id), itm);406            }407408            Ok(())409        }410411        #[weight = 0]412        pub fn transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {413414            let no_perm_mes = "You do not have permissions to modify this collection";415            ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);416            let list_itm = <ApprovedList<T>>::get((collection_id, item_id));417            ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);418419            Self::transfer(origin, collection_id, item_id, new_owner)?;420421            Ok(())422        }423424        #[weight = 0]425        pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {426427            let no_perm_mes = "You do not have permissions to modify this collection";428            ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);429            let list_itm = <ApprovedList<T>>::get((collection_id, item_id));430            ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);431432            // on_nft_received  call433434            Self::transfer(origin, collection_id, item_id, new_owner)?;435436            Ok(())437        }438    }439}440441impl<T: Trait> Module<T> {442    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {443        let list_exists = <AddressTokens<T>>::contains_key((collection_id, owner.clone()));444        if list_exists {445            let mut list = <AddressTokens<T>>::get((collection_id, owner.clone()));446            let item_contains = list.contains(&item_index.clone());447448            if !item_contains {449                list.push(item_index.clone());450            }451452            <AddressTokens<T>>::insert((collection_id, owner.clone()), list);453        } else {454            let mut itm = Vec::new();455            itm.push(item_index.clone());456            <AddressTokens<T>>::insert((collection_id, owner), itm);457        }458459        Ok(())460    }461462    fn remove_token_index(463        collection_id: u64,464        item_index: u64,465        owner: T::AccountId,466    ) -> DispatchResult {467        let list_exists = <AddressTokens<T>>::contains_key((collection_id, owner.clone()));468        if list_exists {469            let mut list = <AddressTokens<T>>::get((collection_id, owner.clone()));470            let item_contains = list.contains(&item_index.clone());471472            if item_contains {473                list.retain(|&item| item != item_index);474                <AddressTokens<T>>::insert((collection_id, owner), list);475            }476        }477478        Ok(())479    }480481    fn move_token_index(482        collection_id: u64,483        item_index: u64,484        old_owner: T::AccountId,485        new_owner: T::AccountId,486    ) -> DispatchResult {487        Self::remove_token_index(collection_id, item_index, old_owner)?;488        Self::add_token_index(collection_id, item_index, new_owner)?;489490        Ok(())491    }492}