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

171      "ReFungible": "(u32, u32)"171      "ReFungible": "(u32, u32)"
172    }172    }
173  },173  },
174  "Ownership": {
175    "Owner": "AccountId",
176    "Fraction": "u128"
177  },
178  "FungibleItemType": {
179    "Collection": "u64",
180    "Owner": "AccountId",
181    "Value": "u128"
182  },
183  "ReFungibleItemType": {
184    "Collection": "u64",
185    "Owner": "Vec<Ownership>",
186    "Data": "Vec<u8>"
187  },
174  "NftItemType": {188  "NftItemType": {
175    "Collection": "u64",189    "Collection": "u64",
176    "Owner": "AccountId",190    "Owner": "AccountId",

no syntactic changes

no syntactic changes

no syntactic changes

no syntactic changes

22
3/// For more guidance on Substrate FRAME, see the example pallet3/// For more guidance on Substrate FRAME, see the example pallet
4/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs4/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs
5
6use codec::{Decode, Encode};5use codec::{Decode, Encode};
7pub use frame_support::{6pub use frame_support::{
8    decl_event, decl_module, decl_storage,7    construct_runtime, decl_event, decl_module, decl_storage,
9    construct_runtime, parameter_types,8    dispatch::DispatchResult,
9    ensure, parameter_types,
10    traits::{Currency, Get, ExistenceRequirement, KeyOwnerProofSystem, OnUnbalanced, Randomness, WithdrawReason, Imbalance},10    traits::{
11        Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,
12        Randomness, WithdrawReason,
13    },
11    weights::{14    weights::{
12        DispatchInfo, PostDispatchInfo, constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},15        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},
13        IdentityFee, Weight, WeightToFeePolynomial, GetDispatchInfo, Pays,16        DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,
17        WeightToFeePolynomial,
14    },18    },
15    StorageValue,19    IsSubType, StorageValue,
16    dispatch::DispatchResult, 
17    IsSubType,
18    ensure
19};20};
2021
21use frame_system::{self as system, ensure_signed};22use frame_system::{self as system, ensure_signed};
22use sp_runtime::sp_std::prelude::Vec;23use sp_runtime::sp_std::prelude::Vec;
23use sp_std::prelude::*;
24use sp_runtime::{24use sp_runtime::{
25	FixedU128, FixedPointOperand, 25    traits::{
26	transaction_validity::{
27		TransactionPriority, ValidTransaction, InvalidTransaction, TransactionValidityError, TransactionValidity26        DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SaturatedConversion, Saturating,
27        SignedExtension, Zero,
28	},28    },
29	traits::{29    transaction_validity::{
30        Saturating, Dispatchable, DispatchInfoOf, PostDispatchInfoOf, SignedExtension, Zero, SaturatedConversion,30        InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,
31        ValidTransaction,
32    },
31	},33    FixedPointOperand, FixedU128,
32};34};
35use sp_std::prelude::*;
3336
34#[cfg(test)]37#[cfg(test)]
35mod mock;38mod mock;
45    // decimal points48    // decimal points
46    Fungible(u32),49    Fungible(u32),
47    // custom data size and decimal points50    // custom data size and decimal points
48	ReFungible(u32, u32),51    ReFungible(u32, u32),
49}52}
5053
51impl Into<u8> for CollectionMode {54impl Into<u8> for CollectionMode {
52    fn into(self) -> u8{55    fn into(self) -> u8 {
53        match self {56        match self {
54            CollectionMode::Invalid => 0,57            CollectionMode::Invalid => 0,
55            CollectionMode::NFT(_) => 1,58            CollectionMode::NFT(_) => 1,
62#[derive(Encode, Decode, Debug, Clone, PartialEq)]65#[derive(Encode, Decode, Debug, Clone, PartialEq)]
63pub enum AccessMode {66pub enum AccessMode {
64    Normal,67    Normal,
65	WhiteList,68    WhiteList,
66}69}
67impl Default for AccessMode { fn default() -> Self { Self::Normal } }70impl Default for AccessMode {
71    fn default() -> Self {
72        Self::Normal
73    }
74}
6875
69impl Default for CollectionMode { fn default() -> Self { Self::Invalid } }76impl Default for CollectionMode {
77    fn default() -> Self {
78        Self::Invalid
79    }
80}
7081
71#[derive(Encode, Decode, Default, Clone, PartialEq)]82#[derive(Encode, Decode, Default, Clone, PartialEq)]
72#[cfg_attr(feature = "std", derive(Debug))]83#[cfg_attr(feature = "std", derive(Debug))]
73pub struct Ownership<AccountId> {84pub struct Ownership<AccountId> {
74    pub owner: AccountId,85    pub owner: AccountId,
75    pub fraction: u12886    pub fraction: u128,
76}87}
7788
78#[derive(Encode, Decode, Default, Clone, PartialEq)]89#[derive(Encode, Decode, Default, Clone, PartialEq)]
87    pub token_prefix: Vec<u8>, // 16 include null escape char98    pub token_prefix: Vec<u8>, // 16 include null escape char
88    pub custom_data_size: u32,99    pub custom_data_size: u32,
89    pub offchain_schema: Vec<u8>,100    pub offchain_schema: Vec<u8>,
90    pub sponsor: AccountId,    // Who pays fees. If set to default address, the fees are applied to the transaction sender101    pub sponsor: AccountId, // Who pays fees. If set to default address, the fees are applied to the transaction sender
91    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship102    pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship
92}103}
93104
122    pub data: Vec<u8>,133    pub data: Vec<u8>,
123}134}
124135
136#[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}
142
143#[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}
153
125pub trait Trait: system::Trait {154pub trait Trait: system::Trait {
126    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;155    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
127
128}156}
129157
130decl_storage! {158decl_storage! {
131    trait Store for Module<T: Trait> as Nft {159    trait Store for Module<T: Trait> as Nft {
132160
133        // Private members161        // Private members
162        NextCollectionID: u64;
134        CreatedCollectionCount: u64;163        CreatedCollectionCount: u64;
164        ChainVersion: u64;
135        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;165        ItemListIndex: map hasher(blake2_128_concat) u64 => u64;
136166
137        pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;167        pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;
138        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;168        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;
139        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;169        pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;
140170
141        // Balance owner per collection map171        /// Balance owner per collection map
142        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;172        pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;
143        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<T::AccountId>;
144173
145        // Item collections174        /// second parameter: item id + owner account id
175        pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;
176
177        /// Item collections
146        pub NftItemList get(fn nft_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;178        pub NftItemList get(fn nft_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;
147        pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;179        pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;
148        pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;180        pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;
149181
182        // Active vesting list
183        // pub VestingList get(fn vesting): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => VestingItem<T::AccountId, T::Moment>;
184
185        /// Index list
150        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;186        pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;
151187
152        // Sponsorship188        // Sponsorship
171207
172        fn deposit_event() = default;208        fn deposit_event() = default;
173209
210        fn on_initialize(now: T::BlockNumber) -> Weight {
211
212            if ChainVersion::get() == 0
213            {
214                let value = NextCollectionID::get();
215                CreatedCollectionCount::put(value);
216                ChainVersion::put(2);
217            }
218
219            0
220        }
221
174        // Create collection of NFT with given parameters222        // Create collection of NFT with given parameters
175        //223        //
176        // @param customDataSz size of custom data in each collection item224        // @param customDataSz size of custom data in each collection item
197            };245            };
198246
199            // check params247            // check params
200            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4"); 248            ensure!(decimal_points <= 4, "decimal_points parameter must be lower than 4");
201249
202            let mut name = collection_name.to_vec();250            let mut name = collection_name.to_vec();
203            name.push(0);251            name.push(0);
248            let sender = ensure_signed(origin)?;296            let sender = ensure_signed(origin)?;
249            Self::check_owner_permissions(collection_id, sender)?;297            Self::check_owner_permissions(collection_id, sender)?;
250298
299            // TODO Items remove
251            <AddressTokens<T>>::remove_prefix(collection_id);300            <AddressTokens<T>>::remove_prefix(collection_id);
252            <ApprovedList<T>>::remove_prefix(collection_id);301            <ApprovedList<T>>::remove_prefix(collection_id);
253            <Balance<T>>::remove_prefix(collection_id);302            <Balance<T>>::remove_prefix(collection_id);
351400
352            Ok(())401            Ok(())
353        }402        }
354        403
355        #[weight = 0]404        #[weight = 0]
356        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {405        pub fn create_item(origin, collection_id: u64, properties: Vec<u8>, owner: T::AccountId) -> DispatchResult {
357406
358            let sender = ensure_signed(origin)?;407            let sender = ensure_signed(origin)?;
359
360            // check size
361            let target_collection = <Collection<T>>::get(collection_id);408            let target_collection = <Collection<T>>::get(collection_id);
362            ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");
363
364            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;409            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
365410
366            // TODO: implement other modes411            match target_collection.mode
367            match target_collection.mode 
368            {412            {
369                CollectionMode::NFT(_) => {413                CollectionMode::NFT(_) => {
414
415                    // check size
416                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");
417
370                // Create nft item418                    // Create nft item
371                    let item = NftItemType {419                    let item = NftItemType {
372                        collection: collection_id,420                        collection: collection_id,
373                        owner: owner,421                        owner: owner,
374                        data: properties.clone(),422                        data: properties.clone(),
375                    };423                    };
376    424
377                    Self::add_nft_item(item)?;425                    Self::add_nft_item(item)?;
378    426
379                },427                },
428                CollectionMode::Fungible(_) => {
429
430                    // check size
431                    ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type");
432
433                    let item = FungibleItemType {
434                        collection: collection_id,
435                        owner: owner,
436                        value: (10 as u128).pow(target_collection.decimal_points)
437                    };
438
439                    Self::add_fungible_item(item)?;
440                },
380                CollectionMode::ReFungible(_, _) => {441                CollectionMode::ReFungible(_, _) => {
442
443                    // check size
444                    ensure!(target_collection.custom_data_size >= properties.len() as u32, "Size of item is too large");
445
381                    let mut owner_list = Vec::new();446                    let mut owner_list = Vec::new();
382                    let value = (10 as u128).pow(target_collection.decimal_points);447                    let value = (10 as u128).pow(target_collection.decimal_points);
383                    owner_list.push(Ownership {owner: owner.clone(), fraction: value});448                    owner_list.push(Ownership {owner: owner.clone(), fraction: value});
387                        owner: owner_list,452                        owner: owner_list,
388                        data: properties.clone()453                        data: properties.clone()
389                    };454                    };
390    455
391                    Self::add_refungible_item(item)?;456                    Self::add_refungible_item(item)?;
392                },457                },
393                _ => { ensure!(1 == 0,"just error"); }458                _ => { ensure!(1 == 0,"just error"); }
411            }476            }
412            let target_collection = <Collection<T>>::get(collection_id);477            let target_collection = <Collection<T>>::get(collection_id);
413478
414            match target_collection.mode 479            match target_collection.mode
415            {480            {
416                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,481                CollectionMode::NFT(_) => Self::burn_nft_item(collection_id, item_id)?,
482                CollectionMode::Fungible(_)  => Self::burn_fungible_item(collection_id, item_id)?,
417                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,483                CollectionMode::ReFungible(_, _)  => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,
418                _ => ()484                _ => ()
419            };485            };
433            let target_collection = <Collection<T>>::get(collection_id);499            let target_collection = <Collection<T>>::get(collection_id);
434500
435            // TODO: implement other modes501            // TODO: implement other modes
436            match target_collection.mode 502            match target_collection.mode
437            {503            {
438                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,504                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,
505                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,
439                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,506                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,
440                _ => ()507                _ => ()
441            };508            };
448515
449            let sender = ensure_signed(origin)?;516            let sender = ensure_signed(origin)?;
450517
451            let item_owner = Self::is_item_owner(sender.clone(), collection_id, item_id);518            // amount param stub
452            if !item_owner519            let amount = 100000000;
453            {
454                Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
455            }
456520
457            let list_exists = <ApprovedList<T>>::contains_key(collection_id, item_id);521            ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id), "Only item owner can call transfer method");
522
523            let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));
458            if list_exists {524            if list_exists {
459525
460                let mut list = <ApprovedList<T>>::get(collection_id, item_id);526                let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));
461                let item_contains = list.contains(&approved.clone());527                let item_contains = list.iter().any(|i| i.approved == approved);
462528
463                if !item_contains {529                if !item_contains {
464                    list.push(approved.clone());530                    list.push(ApprovePermissions { approved: approved.clone(), amount: amount });
531                    <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);
465                }532                }
466            } else {533            } else {
467534
468                let mut itm = Vec::new();535                let mut list = Vec::new();
469                itm.push(approved.clone());536                list.push(ApprovePermissions { approved: approved.clone(), amount: amount });
470                <ApprovedList<T>>::insert(collection_id, item_id, itm);537                <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);
471            }538            }
472539
473            Ok(())540            Ok(())
476        #[weight = 0]543        #[weight = 0]
477        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {544        pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {
478545
479            let mut approved: bool = false; 
480            let sender = ensure_signed(origin)?;546            let sender = ensure_signed(origin)?;
481            let approved_list_exists = <ApprovedList<T>>::contains_key(collection_id, item_id);547            let approved_list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone()));
482            if approved_list_exists548            if approved_list_exists
483            {549            {
484                let list_itm = <ApprovedList<T>>::get(collection_id, item_id);550                let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));
485                approved = list_itm.contains(&recipient.clone());551                let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());
552                ensure!(opt_item.is_some(), "No approve found");
553                ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");
554
555                // remove approve
556                let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))
557                    .into_iter().filter(|i| i.approved != sender.clone()).collect();
558                <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);
486            }559            }
487
488            if !approved560            else
489            {561            {
490                Self::check_owner_or_admin_permissions(collection_id, sender)?;562                Self::check_owner_or_admin_permissions(collection_id, sender)?;
491            }563            }
492            564
493            let target_collection = <Collection<T>>::get(collection_id);565            let target_collection = <Collection<T>>::get(collection_id);
494566
495            match target_collection.mode567            match target_collection.mode
496            {568            {
497                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,569                CollectionMode::NFT(_) => Self::transfer_nft(collection_id, item_id, from, recipient)?,
498                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from, recipient)?,570                CollectionMode::Fungible(_)  => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,
499                // TODO: implement other modes571                CollectionMode::ReFungible(_, _)  => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,
500                _ => ()572                _ => ()
501            };573            };
502574
526        ) -> DispatchResult {598        ) -> DispatchResult {
527            let sender = ensure_signed(origin)?;599            let sender = ensure_signed(origin)?;
528            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;600            Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;
529            601
530            let mut target_collection = <Collection<T>>::get(collection_id);602            let mut target_collection = <Collection<T>>::get(collection_id);
531            target_collection.offchain_schema = schema;603            target_collection.offchain_schema = schema;
532            <Collection<T>>::insert(collection_id, target_collection);604            <Collection<T>>::insert(collection_id, target_collection);
533605
534            Ok(())        606            Ok(())
535        }607        }
536    }608    }
537}609}
538610
539impl<T: Trait> Module<T> {611impl<T: Trait> Module<T> {
612    fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {
613        let current_index = <ItemListIndex>::get(item.collection)
614            .checked_add(1)
615            .expect("Item list index id error");
616        let itemcopy = item.clone();
617        let owner = item.owner.clone();
618        let value = item.value as u64;
540619
541    fn collection_exists(collection_id: u64) -> DispatchResult{620        Self::add_token_index(item.collection, current_index, owner.clone())?;
621
622        <ItemListIndex>::insert(item.collection, current_index);
542        ensure!(<Collection<T>>::contains_key(collection_id), "This collection does not exist");623        <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);
624
625        // Update balance
626        let new_balance = <Balance<T>>::get(item.collection, owner.clone())
627            .checked_add(value)
628            .unwrap();
629        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
630
543        Ok(())631        Ok(())
544    }632    }
545633
634    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {
635        let current_index = <ItemListIndex>::get(item.collection)
636            .checked_add(1)
637            .expect("Item list index id error");
638        let itemcopy = item.clone();
639
640        let value = item.owner.first().unwrap().fraction as u64;
641        let owner = item.owner.first().unwrap().owner.clone();
642
643        Self::add_token_index(item.collection, current_index, owner.clone())?;
644
645        <ItemListIndex>::insert(item.collection, current_index);
646        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);
647
648        // Update balance
649        let new_balance = <Balance<T>>::get(item.collection, owner.clone())
650            .checked_add(value)
651            .unwrap();
652        <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
653
654        Ok(())
655    }
656
657    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {
658        let current_index = <ItemListIndex>::get(item.collection)
659            .checked_add(1)
660            .expect("Item list index id error");
661
662        let item_owner = item.owner.clone();
663        let collection_id = item.collection.clone();
664        Self::add_token_index(collection_id, current_index, item.owner.clone())?;
665
666        <ItemListIndex>::insert(collection_id, current_index);
667        <NftItemList<T>>::insert(collection_id, current_index, item);
668
669        // Update balance
670        let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())
671            .checked_add(1)
672            .unwrap();
673        <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);
674
675        Ok(())
676    }
677
678    fn burn_refungible_item(
679        collection_id: u64,
680        item_id: u64,
681        owner: T::AccountId,
682    ) -> DispatchResult {
683        ensure!(
684            <ReFungibleItemList<T>>::contains_key(collection_id, item_id),
685            "Item does not exists"
686        );
687        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);
688        let item = collection
689            .owner
690            .iter()
691            .filter(|&i| i.owner == owner)
692            .next()
693            .unwrap();
694        Self::remove_token_index(collection_id, item_id, owner.clone())?;
695
696        // remove approve list
697        <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));
698
699        // update balance
700        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())
701            .checked_sub(item.fraction as u64)
702            .unwrap();
703        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);
704
705        <ReFungibleItemList<T>>::remove(collection_id, item_id);
706
707        Ok(())
708    }
709
710    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {
711        ensure!(
712            <NftItemList<T>>::contains_key(collection_id, item_id),
713            "Item does not exists"
714        );
715        let item = <NftItemList<T>>::get(collection_id, item_id);
716        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;
717
718        // remove approve list
719        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));
720
721        // update balance
722        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())
723            .checked_sub(1)
724            .unwrap();
725        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);
726        <NftItemList<T>>::remove(collection_id, item_id);
727
728        Ok(())
729    }
730
731    fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {
732        ensure!(
733            <FungibleItemList<T>>::contains_key(collection_id, item_id),
734            "Item does not exists"
735        );
736        let item = <FungibleItemList<T>>::get(collection_id, item_id);
737        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;
738
739        // remove approve list
740        <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));
741
742        // update balance
743        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())
744            .checked_sub(item.value as u64)
745            .unwrap();
746        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);
747
748        <FungibleItemList<T>>::remove(collection_id, item_id);
749
750        Ok(())
751    }
752
753    fn collection_exists(collection_id: u64) -> DispatchResult {
754        ensure!(
755            <Collection<T>>::contains_key(collection_id),
756            "This collection does not exist"
757        );
758        Ok(())
759    }
760
546    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {761    fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {
547
548        Self::collection_exists(collection_id)?;762        Self::collection_exists(collection_id)?;
549763
550        let target_collection = <Collection<T>>::get(collection_id);764        let target_collection = <Collection<T>>::get(collection_id);
551        ensure!(subject == target_collection.owner, "You do not own this collection");765        ensure!(
766            subject == target_collection.owner,
767            "You do not own this collection"
768        );
552769
553        Ok(())770        Ok(())
554    }771    }
555772
556    fn check_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {773    fn check_owner_or_admin_permissions(
557774        collection_id: u64,
775        subject: T::AccountId,
776    ) -> DispatchResult {
558        Self::collection_exists(collection_id)?;777        Self::collection_exists(collection_id)?;
559778
560        let target_collection = <Collection<T>>::get(collection_id);779        let target_collection = <Collection<T>>::get(collection_id);
563        let no_perm_mes = "You do not have permissions to modify this collection";782        let no_perm_mes = "You do not have permissions to modify this collection";
564        let exists = <AdminList<T>>::contains_key(collection_id);783        let exists = <AdminList<T>>::contains_key(collection_id);
565784
566        if !is_owner785        if !is_owner {
567        {
568            ensure!(exists, no_perm_mes);786            ensure!(exists, no_perm_mes);
569            ensure!(<AdminList<T>>::get(collection_id).contains(&subject), no_perm_mes);787            ensure!(
788                <AdminList<T>>::get(collection_id).contains(&subject),
789                no_perm_mes
790            );
570        }791        }
571        Ok(())792        Ok(())
572    }793    }
573794
574    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool{795    fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {
575
576        let target_collection = <Collection<T>>::get(collection_id);796        let target_collection = <Collection<T>>::get(collection_id);
577797
578        match target_collection.mode {798        match target_collection.mode {
579            CollectionMode::NFT(_) => <NftItemList<T>>::get(collection_id, item_id).owner == subject,799            CollectionMode::NFT(_) => {
800                <NftItemList<T>>::get(collection_id, item_id).owner == subject
580            CollectionMode::Fungible(_) => <FungibleItemList<T>>::get(collection_id, item_id).owner == subject,801            }
802            CollectionMode::Fungible(_) => {
803                <FungibleItemList<T>>::get(collection_id, item_id).owner == subject
581            CollectionMode::ReFungible(_, _)  => <ReFungibleItemList<T>>::get(collection_id, item_id).owner.iter().any(|i| i.owner == subject),804            }
805            CollectionMode::ReFungible(_, _) => {
806                <ReFungibleItemList<T>>::get(collection_id, item_id)
807                    .owner
808                    .iter()
809                    .any(|i| i.owner == subject)
582            CollectionMode::Invalid => false810            }
811            CollectionMode::Invalid => false,
583        }812        }
584    }813    }
585814
586    fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {815    fn transfer_fungible(
816        collection_id: u64,
817        item_id: u64,
818        value: u64,
819        owner: T::AccountId,
820        new_owner: T::AccountId,
821    ) -> DispatchResult {
822        let full_item = <FungibleItemList<T>>::get(collection_id, item_id);
823        let amount = full_item.value;
587824
588        let current_index = <ItemListIndex>::get(item.collection)825        ensure!(amount >= value.into(), "Item balance not enouth");
589        .checked_add(1)
590        .expect("Item list index id error");
591        let itemcopy = item.clone();
592826
593        let value = item.owner.first().unwrap().fraction as u64;827        // update balance
828        let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())
594        let owner = item.owner.first().unwrap().owner.clone();829            .checked_sub(value)
830            .unwrap();
831        <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);
595832
596        Self::add_token_index(item.collection, current_index, owner.clone())?;833        let mut new_owner_account_id = 0;
834        let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());
835        if new_owner_items.len() > 0 {
836            new_owner_account_id = new_owner_items[0];
837        }
597838
598        <ItemListIndex>::insert(item.collection, current_index);839        let val64 = value.into();
599        <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);  
600        
601        // Update balance
602       let new_balance = <Balance<T>>::get(item.collection, owner.clone()).checked_add(value).unwrap();
603       <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
604840
605        Ok(())841        // transfer
842        if amount == val64 && new_owner_account_id == 0 {
843            // change owner
844            // new owner do not have account
845            let mut new_full_item = full_item.clone();
846            new_full_item.owner = new_owner.clone();
606    }847            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
607848
608    fn burn_refungible_item(collection_id: u64, item_id: u64, owner: T::AccountId) -> DispatchResult {849            // update balance
609  850            let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())
610        let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);
611        let item = collection.owner.iter().filter(|&i| i.owner == owner).next().unwrap();851                .checked_add(value)
852                .unwrap();
612        Self::remove_token_index(collection_id, item_id, owner)?;853            <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);
613854
614        // update balance855            // update index collection
615        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone()).checked_sub(item.fraction as u64).unwrap();856            Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;
616        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);857        } else {
858            let mut new_full_item = full_item.clone();
859            new_full_item.value -= val64;
617860
618        // TODO861            // separate amount
619        <ReFungibleItemList<T>>::remove(collection_id, item_id);862            if new_owner_account_id > 0 {
863                // new owner has account
864                let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);
865                item.value += val64;
620866
867                // update balance
868                let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())
869                    .checked_add(value)
870                    .unwrap();
871                <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);
872
873                <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);
874            } else {
875                // new owner do not have account
876                let item = FungibleItemType {
877                    collection: collection_id,
878                    owner: new_owner.clone(),
879                    value: val64,
880                };
881
882                Self::add_fungible_item(item)?;
883            }
884
885            if amount == val64 {
886                Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;
887
888                // remove approve list
889                <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));
890                <FungibleItemList<T>>::remove(collection_id, item_id);
891            }
892
893            <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
894        }
895
621        Ok(())896        Ok(())
622    }897    }
623898
624    fn transfer_refungible(collection_id: u64, item_id: u64, value: u64, owner: T::AccountId, new_owner: T::AccountId) -> DispatchResult {899    fn transfer_refungible(
625900        collection_id: u64,
901        item_id: u64,
902        value: u64,
903        owner: T::AccountId,
904        new_owner: T::AccountId,
905    ) -> DispatchResult {
626        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);906        let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);
627        let item = full_item.owner.iter().filter(|i| i.owner == owner).next().unwrap();907        let item = full_item
908            .owner
909            .iter()
910            .filter(|i| i.owner == owner)
911            .next()
912            .unwrap();
628        let amount = item.fraction;913        let amount = item.fraction;
629914
630        ensure!(amount >= value.into(),"Item balance not enouth");915        ensure!(amount >= value.into(), "Item balance not enouth");
631916
632        // update balance917        // update balance
633        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone()).checked_sub(value).unwrap();918        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())
919            .checked_sub(value)
920            .unwrap();
634        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);921        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);
635922
636        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone()).checked_add(value).unwrap();923        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())
924            .checked_add(value)
925            .unwrap();
637        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);926        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);
638927
639        let old_owner = item.owner.clone();928        let old_owner = item.owner.clone();
640        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);929        let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);
641        let val64 = value.into();930        let val64 = value.into();
642931
643        // transfer932        // transfer
644        if amount == val64 && !new_owner_has_account933        if amount == val64 && !new_owner_has_account {
645        {
646            // change owner934            // change owner
647            // new owner do not have account935            // new owner do not have account
648            let mut new_full_item = full_item.clone();936            let mut new_full_item = full_item.clone();
649            new_full_item.owner.iter_mut().find(|i| i.owner == owner).unwrap().owner = new_owner.clone();937            new_full_item
938                .owner
939                .iter_mut()
940                .find(|i| i.owner == owner)
941                .unwrap()
942                .owner = new_owner.clone();
650            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);943            <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
651944
652            // update index collection945            // update index collection
653            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;946            Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;
654        }947        } else {
655        else
656        {
657            let mut new_full_item = full_item.clone();948            let mut new_full_item = full_item.clone();
658            new_full_item.owner.iter_mut().find(|i| i.owner == owner).unwrap().fraction -= val64;949            new_full_item
950                .owner
951                .iter_mut()
952                .find(|i| i.owner == owner)
953                .unwrap()
954                .fraction -= val64;
659955
660            // separate amount956            // separate amount
661            if new_owner_has_account {957            if new_owner_has_account {
662                // new owner has account958                // new owner has account
663                new_full_item.owner.iter_mut().find(|i| i.owner == new_owner).unwrap().fraction += val64;959                new_full_item
960                    .owner
961                    .iter_mut()
962                    .find(|i| i.owner == new_owner)
963                    .unwrap()
664            }964                    .fraction += val64;
665            else965            } else {
666            {
667                // new owner do not have account966                // new owner do not have account
668                new_full_item.owner.push(Ownership { owner: new_owner.clone(), fraction: val64});967                new_full_item.owner.push(Ownership {
968                    owner: new_owner.clone(),
969                    fraction: val64,
970                });
669                Self::add_token_index(collection_id, item_id, new_owner.clone())?;971                Self::add_token_index(collection_id, item_id, new_owner.clone())?;
670            }972            }
671973
674976
675        Ok(())977        Ok(())
676    }978    }
677    
678    fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {
679979
680        let current_index = <ItemListIndex>::get(item.collection)980    fn transfer_nft(
681        .checked_add(1)981        collection_id: u64,
682        .expect("Item list index id error");
683        let itemcopy = item.clone();
684
685        Self::add_token_index(item.collection, current_index, item.owner.clone())?;
686
687        <ItemListIndex>::insert(item.collection, current_index);982        item_id: u64,
688        <NftItemList<T>>::insert(item.collection, current_index, item);
689
690        // Update balance
691        let new_balance = <Balance<T>>::get(itemcopy.collection, itemcopy.owner.clone()).checked_add(1).unwrap();
692        <Balance<T>>::insert(itemcopy.collection, itemcopy.owner.clone(), new_balance);
693
694        Ok(())
695    }
696
697    fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {
698  
699        let item = <NftItemList<T>>::get(collection_id, item_id);
700        Self::remove_token_index(collection_id, item_id, item.owner.clone())?;983        sender: T::AccountId,
701
702        // update balance
703        let new_balance = <Balance<T>>::get(collection_id, item.owner.clone()).checked_sub(1).unwrap();
704        <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);984        new_owner: T::AccountId,
705        <NftItemList<T>>::remove(collection_id, item_id);
706
707        Ok(())985    ) -> DispatchResult {
708    }
709
710    fn transfer_nft(collection_id: u64, item_id: u64, sender: T::AccountId, new_owner: T::AccountId) -> DispatchResult {
711
712        let mut item = <NftItemList<T>>::get(collection_id, item_id);986        let mut item = <NftItemList<T>>::get(collection_id, item_id);
713987
714        ensure!(sender == item.owner,"sender parameter and item owner must be equal");988        ensure!(
989            sender == item.owner,
990            "sender parameter and item owner must be equal"
991        );
715992
716        // update balance993        // update balance
717        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone()).checked_sub(1).unwrap();994        let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())
995            .checked_sub(1)
996            .unwrap();
718        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);997        <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);
719998
720        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone()).checked_add(1).unwrap();999        let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())
1000            .checked_add(1)
1001            .unwrap();
721        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);1002        <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);
7221003
723        // change owner1004        // change owner
726        <NftItemList<T>>::insert(collection_id, item_id, item);1007        <NftItemList<T>>::insert(collection_id, item_id, item);
7271008
728        // update index collection1009        // update index collection
729        Self::move_token_index(collection_id, item_id, old_owner, new_owner.clone())?;1010        Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;
7301011
731        // reset approved list1012        // reset approved list
732        let itm: Vec<T::AccountId> = Vec::new();1013        <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));
733        <ApprovedList<T>>::insert(collection_id, item_id, itm);
734
735        Ok(())1014        Ok(())
736    }1015    }
787    }1066    }
788}1067}
7891068
790
791////////////////////////////////////////////////////////////////////////////////////////////////////1069////////////////////////////////////////////////////////////////////////////////////////////////////
792// Economic models1070// Economic models
7931071
794/// Fee multiplier.1072/// Fee multiplier.
795pub type Multiplier = FixedU128;1073pub type Multiplier = FixedU128;
7961074
797type BalanceOf<T> =1075type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<
798	<<T as transaction_payment::Trait>::Currency as Currency<<T as system::Trait>::AccountId>>::Balance;1076    <T as system::Trait>::AccountId,
1077>>::Balance;
799type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<1078type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<
800	<T as system::Trait>::AccountId,>>::NegativeImbalance;1079    <T as system::Trait>::AccountId,
1080>>::NegativeImbalance;
8011081
802
803
804/// Require the transactor pay for themselves and maybe include a tip to gain additional priority1082/// Require the transactor pay for themselves and maybe include a tip to gain additional priority
805/// in the queue.1083/// in the queue.
806#[derive(Encode, Decode, Clone, Eq, PartialEq)]1084#[derive(Encode, Decode, Clone, Eq, PartialEq)]
807pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(#[codec(compact)] BalanceOf<T>);1085pub struct ChargeTransactionPayment<T: transaction_payment::Trait + Send + Sync>(
1086    #[codec(compact)] BalanceOf<T>,
1087);
8081088
809impl<T:Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug for ChargeTransactionPayment<T> {1089impl<T: Trait + transaction_payment::Trait + Send + Sync> sp_std::fmt::Debug
1090    for ChargeTransactionPayment<T>
1091{
810	#[cfg(feature = "std")]1092    #[cfg(feature = "std")]
811	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1093    fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
812		write!(f, "ChargeTransactionPayment<{:?}>", self.0)1094        write!(f, "ChargeTransactionPayment<{:?}>", self.0)
813	}1095    }
814	#[cfg(not(feature = "std"))]1096    #[cfg(not(feature = "std"))]
815	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {1097    fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
816		Ok(())1098        Ok(())
817	}1099    }
818}1100}
8191101
820impl<T:Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T> where1102impl<T: Trait + transaction_payment::Trait + Send + Sync> ChargeTransactionPayment<T>
1103where
821	T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Module<T>, T>,1104    T::Call:
1105        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,
822	BalanceOf<T>: Send + Sync + FixedPointOperand,1106    BalanceOf<T>: Send + Sync + FixedPointOperand,
823{1107{
824	/// utility constructor. Used only in client/factory code.1108    /// utility constructor. Used only in client/factory code.
825	pub fn from(fee: BalanceOf<T>) -> Self {1109    pub fn from(fee: BalanceOf<T>) -> Self {
826		Self(fee)1110        Self(fee)
827	}1111    }
8281112
829    pub fn traditional_fee(1113    pub fn traditional_fee(
830        len: usize,1114        len: usize,
831        info: &DispatchInfoOf<T::Call>,1115        info: &DispatchInfoOf<T::Call>,
832        tip: BalanceOf<T>,1116        tip: BalanceOf<T>,
833    ) -> BalanceOf<T> where1117    ) -> BalanceOf<T>
1118    where
834        T::Call: Dispatchable<Info=DispatchInfo>,1119        T::Call: Dispatchable<Info = DispatchInfo>,
835    {1120    {
836        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)1121        <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)
837    }1122    }
8381123
839	fn withdraw_fee(1124    fn withdraw_fee(
840		&self,1125        &self,
841        who: &T::AccountId,1126        who: &T::AccountId,
842        call: &T::Call,1127        call: &T::Call,
843		info: &DispatchInfoOf<T::Call>,1128        info: &DispatchInfoOf<T::Call>,
844		len: usize,1129        len: usize,
845	) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {1130    ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {
846        let tip = self.0;1131        let tip = self.0;
8471132
848        // Set fee based on call type. Creating collection costs 1 Unique.1133        // Set fee based on call type. Creating collection costs 1 Unique.
849        // All other transactions have traditional fees so far1134        // All other transactions have traditional fees so far
850        let fee = match call.is_sub_type() {1135        let fee = match call.is_sub_type() {
851            Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),1136            Some(Call::create_collection(..)) => <BalanceOf<T>>::from(1_000_000_000),
852            _ => Self::traditional_fee(len, info, tip)1137            _ => Self::traditional_fee(len, info, tip), // Flat fee model, use only for testing purposes
853
854            // Flat fee model, use only for testing purposes1138                                                        // _ => <BalanceOf<T>>::from(100)
855            // _ => <BalanceOf<T>>::from(100)
856        };1139        };
8571140
858        // Determine who is paying transaction fee based on ecnomic model1141        // Determine who is paying transaction fee based on ecnomic model
859        // Parse call to extract collection ID and access collection sponsor1142        // Parse call to extract collection ID and access collection sponsor
860        let sponsor: T::AccountId = match call.is_sub_type() {1143        let sponsor: T::AccountId = match call.is_sub_type() {
861            Some(Call::create_item(collection_id, _properties, _owner)) => {1144            Some(Call::create_item(collection_id, _properties, _owner)) => {
862                <Collection<T>>::get(collection_id).sponsor1145                <Collection<T>>::get(collection_id).sponsor
863            },1146            }
864            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {1147            Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {
865                <Collection<T>>::get(collection_id).sponsor1148                <Collection<T>>::get(collection_id).sponsor
866            },1149            }
8671150
868            _ => T::AccountId::default()1151            _ => T::AccountId::default(),
869        };1152        };
8701153
871        let mut who_pays_fee: T::AccountId = sponsor.clone();1154        let mut who_pays_fee: T::AccountId = sponsor.clone();
872        if sponsor == T::AccountId::default() {1155        if sponsor == T::AccountId::default() {
873            who_pays_fee = who.clone();1156            who_pays_fee = who.clone();
874        }1157        }
8751158
876		// Only mess with balances if fee is not zero.1159        // Only mess with balances if fee is not zero.
877		if fee.is_zero() {1160        if fee.is_zero() {
878			return Ok((fee, None));1161            return Ok((fee, None));
879		}1162        }
8801163
881		match <T as transaction_payment::Trait>::Currency::withdraw(1164        match <T as transaction_payment::Trait>::Currency::withdraw(
882			&who_pays_fee,1165            &who_pays_fee,
883			fee,1166            fee,
884			if tip.is_zero() {1167            if tip.is_zero() {
885				WithdrawReason::TransactionPayment.into()1168                WithdrawReason::TransactionPayment.into()
886			} else {1169            } else {
887				WithdrawReason::TransactionPayment | WithdrawReason::Tip1170                WithdrawReason::TransactionPayment | WithdrawReason::Tip
888			},1171            },
889			ExistenceRequirement::KeepAlive,1172            ExistenceRequirement::KeepAlive,
890		) {1173        ) {
891			Ok(imbalance) => Ok((fee, Some(imbalance))),1174            Ok(imbalance) => Ok((fee, Some(imbalance))),
892			Err(_) => Err(InvalidTransaction::Payment.into()),1175            Err(_) => Err(InvalidTransaction::Payment.into()),
893		}1176        }
894	}1177    }
895}1178}
8961179
897impl<T:Trait + transaction_payment::Trait + Send + Sync> SignedExtension for ChargeTransactionPayment<T> where1180impl<T: Trait + transaction_payment::Trait + Send + Sync> SignedExtension
1181    for ChargeTransactionPayment<T>
1182where
898    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,1183    BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,
899    T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Module<T>, T>,1184    T::Call:
1185        Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Module<T>, T>,
900{1186{
901	const IDENTIFIER: &'static str = "ChargeTransactionPayment";1187    const IDENTIFIER: &'static str = "ChargeTransactionPayment";
902	type AccountId = T::AccountId;1188    type AccountId = T::AccountId;
903	type Call = T::Call;1189    type Call = T::Call;
904	type AdditionalSigned = ();1190    type AdditionalSigned = ();
905	type Pre = (BalanceOf<T>, Self::AccountId, Option<NegativeImbalanceOf<T>>, BalanceOf<T>);1191    type Pre = (
1192        BalanceOf<T>,
1193        Self::AccountId,
1194        Option<NegativeImbalanceOf<T>>,
1195        BalanceOf<T>,
1196    );
906	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> { Ok(()) }1197    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
1198        Ok(())
1199    }
9071200
908	fn validate(1201    fn validate(
909		&self,1202        &self,
910		who: &Self::AccountId,1203        who: &Self::AccountId,
911		call: &Self::Call,1204        call: &Self::Call,
912		info: &DispatchInfoOf<Self::Call>,1205        info: &DispatchInfoOf<Self::Call>,
913		len: usize,1206        len: usize,
914	) -> TransactionValidity {1207    ) -> TransactionValidity {
915		let (fee, _) = self.withdraw_fee(who, call, info, len)?;1208        let (fee, _) = self.withdraw_fee(who, call, info, len)?;
9161209
917		let mut r = ValidTransaction::default();1210        let mut r = ValidTransaction::default();
918		// NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which1211        // NOTE: we probably want to maximize the _fee (of any type) per weight unit_ here, which
919		// will be a bit more than setting the priority to tip. For now, this is enough.1212        // will be a bit more than setting the priority to tip. For now, this is enough.
920		r.priority = fee.saturated_into::<TransactionPriority>();1213        r.priority = fee.saturated_into::<TransactionPriority>();
921		Ok(r)1214        Ok(r)
922	}1215    }
9231216
924	fn pre_dispatch(1217    fn pre_dispatch(
925		self,1218        self,
926		who: &Self::AccountId,1219        who: &Self::AccountId,
927		call: &Self::Call,1220        call: &Self::Call,
928		info: &DispatchInfoOf<Self::Call>,1221        info: &DispatchInfoOf<Self::Call>,
929		len: usize1222        len: usize,
930	) -> Result<Self::Pre, TransactionValidityError> {1223    ) -> Result<Self::Pre, TransactionValidityError> {
931		let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;1224        let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;
932		Ok((self.0, who.clone(), imbalance, fee))1225        Ok((self.0, who.clone(), imbalance, fee))
933	}1226    }
9341227
935	fn post_dispatch(1228    fn post_dispatch(
936		pre: Self::Pre,1229        pre: Self::Pre,
937		info: &DispatchInfoOf<Self::Call>,1230        info: &DispatchInfoOf<Self::Call>,
938		post_info: &PostDispatchInfoOf<Self::Call>,1231        post_info: &PostDispatchInfoOf<Self::Call>,
939		len: usize,1232        len: usize,
940		_result: &DispatchResult,1233        _result: &DispatchResult,
941	) -> Result<(), TransactionValidityError> {1234    ) -> Result<(), TransactionValidityError> {
942		let (tip, who, imbalance, fee) = pre;1235        let (tip, who, imbalance, fee) = pre;
943		if let Some(payed) = imbalance {1236        if let Some(payed) = imbalance {
944			let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(1237            let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(
945				len as u32,1238                len as u32, info, post_info, tip,
946				info,
947				post_info,
948				tip,
949			);1239            );
950			let refund = fee.saturating_sub(actual_fee);1240            let refund = fee.saturating_sub(actual_fee);
951			let actual_payment = match <T as transaction_payment::Trait>::Currency::deposit_into_existing(&who, refund) {1241            let actual_payment =
1242                match <T as transaction_payment::Trait>::Currency::deposit_into_existing(
1243                    &who, refund,
1244                ) {
952				Ok(refund_imbalance) => {1245                    Ok(refund_imbalance) => {
953					// The refund cannot be larger than the up front payed max weight.1246                        // The refund cannot be larger than the up front payed max weight.
954					// `PostDispatchInfo::calc_unspent` guards against such a case.1247                        // `PostDispatchInfo::calc_unspent` guards against such a case.
955					match payed.offset(refund_imbalance) {1248                        match payed.offset(refund_imbalance) {
956						Ok(actual_payment) => actual_payment,1249                            Ok(actual_payment) => actual_payment,
957						Err(_) => return Err(InvalidTransaction::Payment.into()),1250                            Err(_) => return Err(InvalidTransaction::Payment.into()),
958					}1251                        }
959				}1252                    }
960				// We do not recreate the account using the refund. The up front payment1253                    // We do not recreate the account using the refund. The up front payment
961				// is gone in that case.1254                    // is gone in that case.
962				Err(_) => payed,1255                    Err(_) => payed,
963			};1256                };
964			let imbalances = actual_payment.split(tip);1257            let imbalances = actual_payment.split(tip);
965			<T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(Some(imbalances.0).into_iter()1258            <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(
966				.chain(Some(imbalances.1)));1259                Some(imbalances.0).into_iter().chain(Some(imbalances.1)),
1260            );
967		}1261        }
968		Ok(())1262        Ok(())
969	}1263    }
970}1264}
9711265

1// Creating mock runtime here1// Creating mock runtime here
22
3use crate::{Module, Trait};3use crate::{Module, Trait};
4use frame_support::{
5    impl_outer_origin, parameter_types,
6    weights::{
7        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight},
8        Weight,
9    },
10};
4use frame_system as system;11use frame_system as system;
5use sp_core::H256;12use sp_core::H256;
6use sp_runtime::{13use sp_runtime::{
7    testing::Header,14    testing::Header,
8    traits::{BlakeTwo256, IdentityLookup, Saturating},15    traits::{BlakeTwo256, IdentityLookup, Saturating},
9    Perbill,16    Perbill,
10};17};
11use frame_support::{
12    parameter_types, impl_outer_origin,
13    weights::{
14        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight},
15        Weight,
16    },
17};
1818
19impl_outer_origin! {19impl_outer_origin! {
20    pub enum Origin for Test {}20    pub enum Origin for Test {}

1// Tests to be written here1// Tests to be written here
2use crate::mock::*;2use crate::mock::*;
3use crate::{CollectionMode, Ownership};3use crate::{ApprovePermissions, CollectionMode, Ownership};
4use frame_support::{assert_noop, assert_ok};4use frame_support::{assert_noop, assert_ok};
55
6#[test]6#[test]
52    });69    });
53}70}
71
72#[test]
73fn create_fungible_item() {
74    new_test_ext().execute_with(|| {
75        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
76        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
77        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
78        let mode: CollectionMode = CollectionMode::Fungible(3);
79
80        let origin1 = Origin::signed(1);
81        assert_ok!(TemplateModule::create_collection(
82            origin1.clone(),
83            col_name1.clone(),
84            col_desc1.clone(),
85            token_prefix1.clone(),
86            mode
87        ));
88        assert_eq!(TemplateModule::collection(1).owner, 1);
89
90        assert_ok!(TemplateModule::create_item(
91            origin1.clone(),
92            1,
93            [].to_vec(),
94            1
95        ));
96        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
97        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
98        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
99    });
100}
101
102#[test]
103fn transfer_fungible_item() {
104    new_test_ext().execute_with(|| {
105        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
106        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
107        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
108        let mode: CollectionMode = CollectionMode::Fungible(3);
109
110        let origin1 = Origin::signed(1);
111        let origin2 = Origin::signed(2);
112        assert_ok!(TemplateModule::create_collection(
113            origin1.clone(),
114            col_name1.clone(),
115            col_desc1.clone(),
116            token_prefix1.clone(),
117            mode
118        ));
119        assert_eq!(TemplateModule::collection(1).owner, 1);
120
121        assert_ok!(TemplateModule::create_item(
122            origin1.clone(),
123            1,
124            [].to_vec(),
125            1
126        ));
127        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
128        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
129        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
130
131        // change owner scenario
132        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));
133        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
134        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);
135        assert_eq!(TemplateModule::balance_count(1, 1), 0);
136        assert_eq!(TemplateModule::balance_count(1, 2), 1000);
137        assert_eq!(TemplateModule::address_tokens(1, 1), []);
138        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
139
140        // split item scenario
141        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));
142        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
143        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);
144        assert_eq!(TemplateModule::balance_count(1, 2), 500);
145        assert_eq!(TemplateModule::balance_count(1, 3), 500);
146        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
147        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
148
149        // split item and new owner has account scenario
150        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));
151        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);
152        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);
153        assert_eq!(TemplateModule::balance_count(1, 2), 300);
154        assert_eq!(TemplateModule::balance_count(1, 3), 700);
155        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
156        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
157    });
158}
54159
55#[test]160#[test]
56fn transfer_refungible_item() {161fn transfer_refungible_item() {
140    });292    });
141}293}
142294
143295#[test]
144// #[test]296fn nft_approve_and_transfer_from() {
145// fn create_collection_test() {297    new_test_ext().execute_with(|| {
146//     new_test_ext().execute_with(|| {298        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
147//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();299        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
148//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();300        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
149//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();301        let mode: CollectionMode = CollectionMode::NFT(2000);
150302
151//         let size = 1024;303        let origin1 = Origin::signed(1);
152//         let origin1 = Origin::signed(1);304        let origin2 = Origin::signed(2);
153//         assert_ok!(TemplateModule::create_collection(305        assert_ok!(TemplateModule::create_collection(
154//             origin1.clone(),306            origin1.clone(),
155//             col_name1.clone(),307            col_name1.clone(),
156//             col_desc1.clone(),308            col_desc1.clone(),
157//             token_prefix1.clone(),309            token_prefix1.clone(),
158//             size310            mode
159//         ));311        ));
160//         assert_eq!(TemplateModule::collection(1).owner, 1);312        assert_eq!(TemplateModule::collection(1).owner, 1);
161//     });313
162// }314        assert_ok!(TemplateModule::create_item(
163315            origin1.clone(),
164// #[test]316            1,
165// fn change_collection_owner() {317            [1, 2, 3].to_vec(),
166//     new_test_ext().execute_with(|| {318            1
167//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();319        ));
168//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();320        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
169//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();321        assert_eq!(TemplateModule::balance_count(1, 1), 1);
170322        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
171//         let size = 1024;323
172//         let origin1 = Origin::signed(1);324        assert_noop!(
173325            TemplateModule::transfer_from(origin2.clone(), 1, 3, 1, 1, 1),
174//         assert_ok!(TemplateModule::create_collection(326            "You do not have permissions to modify this collection"
175//             origin1.clone(),327        );
176//             col_name1.clone(),328
177//             col_desc1.clone(),329        // do approve
178//             token_prefix1.clone(),330        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
179//             size331        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
180//         ));332        assert_ok!(TemplateModule::approve(origin1.clone(), 10, 1, 1));
181//         assert_ok!(TemplateModule::change_collection_owner(333        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);
182//             origin1.clone(),334        assert_eq!(
183//             1,335            TemplateModule::approved(1, (1, 1))[0],
184//             2336            ApprovePermissions {
185//         ));337                approved: 2,
186//         assert_eq!(TemplateModule::collection(1).owner, 2);338                amount: 100000000
187//     });339            }
188// }340        );
189341
190// #[test]342        assert_ok!(TemplateModule::transfer_from(
191// fn destroy_collection() {343            origin2.clone(),
192//     new_test_ext().execute_with(|| {344            1,
193//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();345            3,
194//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();346            1,
195//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();347            1,
196348            1
197//         let size = 1024;349        ));
198//         let origin1 = Origin::signed(1);350        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);
199351    });
200//         assert_ok!(TemplateModule::create_collection(352}
201//             origin1.clone(),353
202//             col_name1.clone(),354#[test]
203//             col_desc1.clone(),355fn refungible_approve_and_transfer_from() {
204//             token_prefix1.clone(),356    new_test_ext().execute_with(|| {
205//             size357        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
206//         ));358        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
207//         assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));359        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
208//     });360        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
209// }361
210362        let origin1 = Origin::signed(1);
211// #[test]363        let origin2 = Origin::signed(2);
212// fn create_item() {364        assert_ok!(TemplateModule::create_collection(
213//     new_test_ext().execute_with(|| {365            origin1.clone(),
214//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();366            col_name1.clone(),
215//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();367            col_desc1.clone(),
216//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();368            token_prefix1.clone(),
217369            mode
218//         let size = 1024;370        ));
219//         let origin1 = Origin::signed(1);371        assert_eq!(TemplateModule::collection(1).owner, 1);
220//         let origin2 = Origin::signed(2);372
221373        assert_ok!(TemplateModule::create_item(
222//         assert_ok!(TemplateModule::create_collection(374            origin1.clone(),
223//             origin1.clone(),375            1,
224//             col_name1.clone(),376            [1, 2, 3].to_vec(),
225//             col_desc1.clone(),377            1
226//             token_prefix1.clone(),378        ));
227//             size379        assert_eq!(
228//         ));380            TemplateModule::refungible_item_id(1, 1).data,
229//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));381            [1, 2, 3].to_vec()
230//         assert_ok!(TemplateModule::create_item(382        );
231//             origin2.clone(),383        assert_eq!(
232//             1,384            TemplateModule::refungible_item_id(1, 1).owner[0],
233//             [1, 1, 1].to_vec()385            Ownership {
234//         ));386                owner: 1,
387                fraction: 1000
388            }
389        );
390        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
391        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
392
393        assert_noop!(
394            TemplateModule::transfer_from(origin2.clone(), 1, 3, 1, 1, 1),
395            "You do not have permissions to modify this collection"
396        );
397
398        // do approve
399        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
400        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
401        assert_ok!(TemplateModule::approve(origin1.clone(), 10, 1, 1));
402        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);
403        assert_eq!(
404            TemplateModule::approved(1, (1, 1))[0],
405            ApprovePermissions {
406                approved: 2,
407                amount: 100000000
408            }
409        );
410
411        assert_ok!(TemplateModule::transfer_from(
412            origin2.clone(),
413            1,
414            3,
415            1,
416            1,
417            100
418        ));
419        assert_eq!(TemplateModule::balance_count(1, 1), 900);
420        assert_eq!(TemplateModule::balance_count(1, 3), 100);
421        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
422        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);
423
424        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
425        assert_eq!(
426            TemplateModule::approved(1, (1, 1))[0],
427            ApprovePermissions {
428                approved: 10,
429                amount: 100000000
430            }
431        );
432    });
433}
434
435#[test]
436fn fungible_approve_and_transfer_from() {
437    new_test_ext().execute_with(|| {
438        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
439        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
440        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
441        let mode: CollectionMode = CollectionMode::Fungible(3);
442
443        let origin1 = Origin::signed(1);
444        let origin2 = Origin::signed(2);
445        assert_ok!(TemplateModule::create_collection(
446            origin1.clone(),
447            col_name1.clone(),
448            col_desc1.clone(),
449            token_prefix1.clone(),
450            mode
451        ));
452        assert_eq!(TemplateModule::collection(1).owner, 1);
453
454        assert_ok!(TemplateModule::create_item(
455            origin1.clone(),
456            1,
457            [].to_vec(),
458            1
459        ));
460        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
461        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
462        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
463
464        assert_noop!(
465            TemplateModule::transfer_from(origin2.clone(), 1, 3, 1, 1, 1),
466            "You do not have permissions to modify this collection"
467        );
468
469        // do approve
470        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
471        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
472        assert_ok!(TemplateModule::approve(origin1.clone(), 10, 1, 1));
473        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);
474        assert_eq!(
475            TemplateModule::approved(1, (1, 1))[0],
476            ApprovePermissions {
477                approved: 2,
478                amount: 100000000
479            }
480        );
481
482        assert_ok!(TemplateModule::transfer_from(
483            origin2.clone(),
484            1,
485            3,
486            1,
487            1,
488            100
489        ));
490        assert_eq!(TemplateModule::balance_count(1, 1), 900);
491        assert_eq!(TemplateModule::balance_count(1, 3), 100);
492        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
493        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
494
495        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
496        assert_eq!(
497            TemplateModule::approved(1, (1, 1))[0],
498            ApprovePermissions {
499                approved: 10,
500                amount: 100000000
501            }
502        );
503
504        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
505        assert_ok!(TemplateModule::transfer_from(
506            origin2.clone(),
507            1,
508            3,
509            1,
510            1,
511            900
512        ));
513        assert_eq!(TemplateModule::balance_count(1, 1), 0);
514        assert_eq!(TemplateModule::balance_count(1, 3), 1000);
515        assert_eq!(TemplateModule::address_tokens(1, 1), []);
516        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
517
518        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);
519    });
520}
521
522#[test]
523fn change_collection_owner() {
524    new_test_ext().execute_with(|| {
525        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
526        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
527        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
528        let mode: CollectionMode = CollectionMode::NFT(2000);
529
530        let origin1 = Origin::signed(1);
531        assert_ok!(TemplateModule::create_collection(
532            origin1.clone(),
533            col_name1.clone(),
534            col_desc1.clone(),
535            token_prefix1.clone(),
536            mode
537        ));
538        assert_ok!(TemplateModule::change_collection_owner(
539            origin1.clone(),
540            1,
541            2
542        ));
543        assert_eq!(TemplateModule::collection(1).owner, 2);
544    });
545}
546
547#[test]
548fn destroy_collection() {
549    new_test_ext().execute_with(|| {
550        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
551        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
552        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
553        let mode: CollectionMode = CollectionMode::NFT(2000);
554
555        let origin1 = Origin::signed(1);
556        assert_ok!(TemplateModule::create_collection(
557            origin1.clone(),
558            col_name1.clone(),
559            col_desc1.clone(),
560            token_prefix1.clone(),
561            mode
562        ));
563        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
564    });
565}
566
567#[test]
568fn burn_nft_item() {
569    new_test_ext().execute_with(|| {
570        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
571        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
572        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
573        let mode: CollectionMode = CollectionMode::NFT(2000);
574
575        let origin1 = Origin::signed(1);
576        let origin2 = Origin::signed(2);
577        assert_ok!(TemplateModule::create_collection(
578            origin1.clone(),
579            col_name1.clone(),
580            col_desc1.clone(),
581            token_prefix1.clone(),
582            mode
583        ));
584        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
585        assert_ok!(TemplateModule::create_item(
586            origin2.clone(),
587            1,
588            [1, 2, 3].to_vec(),
589            1
590        ));
591
592        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
593
594        // check balance (collection with id = 1, user id = 1)
595        assert_eq!(TemplateModule::balance_count(1, 1), 1);
596
597        // burn item
598        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
599        assert_noop!(
600            TemplateModule::burn_item(origin1.clone(), 1, 1),
601            "Item does not exists"
602        );
603
604        assert_eq!(TemplateModule::balance_count(1, 1), 0);
605    });
606}
607
608#[test]
609fn burn_fungible_item() {
610    new_test_ext().execute_with(|| {
611        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
612        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
613        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
614        let mode: CollectionMode = CollectionMode::Fungible(3);
615
616        let origin1 = Origin::signed(1);
617        let origin2 = Origin::signed(2);
618        assert_ok!(TemplateModule::create_collection(
619            origin1.clone(),
620            col_name1.clone(),
621            col_desc1.clone(),
622            token_prefix1.clone(),
623            mode
624        ));
625        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
626        assert_ok!(TemplateModule::create_item(
627            origin2.clone(),
628            1,
629            [].to_vec(),
630            1
631        ));
235632
236//         // check balance (collection with id = 1, user id = 2)633        // check balance (collection with id = 1, user id = 1)
237//         assert_eq!(TemplateModule::balance_count((1, 2)), 1);634        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
238//     });635
239// }636        // burn item
240637        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
241// #[test]638        assert_noop!(
242// fn burn_item() {639            TemplateModule::burn_item(origin1.clone(), 1, 1),
243//     new_test_ext().execute_with(|| {640            "Item does not exists"
244//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();641        );
245//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();642
246//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();643        assert_eq!(TemplateModule::balance_count(1, 1), 0);
247644    });
248//         let size = 1024;645}
249//         let origin1 = Origin::signed(1);646
250//         let origin2 = Origin::signed(2);647#[test]
251648fn burn_refungible_item() {
252//         assert_ok!(TemplateModule::create_collection(649    new_test_ext().execute_with(|| {
253//             origin1.clone(),650        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
254//             col_name1.clone(),651        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
255//             col_desc1.clone(),652        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
256//             token_prefix1.clone(),653        let mode: CollectionMode = CollectionMode::ReFungible(200, 3);
257//             size654
258//         ));655        let origin1 = Origin::signed(1);
259//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));656        let origin2 = Origin::signed(2);
260//         assert_ok!(TemplateModule::create_item(657        assert_ok!(TemplateModule::create_collection(
261//             origin2.clone(),658            origin1.clone(),
262//             1,659            col_name1.clone(),
263//             [1, 1, 1].to_vec()660            col_desc1.clone(),
264//         ));661            token_prefix1.clone(),
662            mode
663        ));
664        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
665        assert_ok!(TemplateModule::create_item(
666            origin2.clone(),
667            1,
668            [1, 2, 3].to_vec(),
669            1
670        ));
671
672        assert_eq!(
673            TemplateModule::refungible_item_id(1, 1).data,
674            [1, 2, 3].to_vec()
675        );
265676
266//         // check balance (collection with id = 1, user id = 2)677        // check balance (collection with id = 1, user id = 2)
267//         assert_eq!(TemplateModule::balance_count((1, 2)), 1);678        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
268679
269//         // burn item680        // burn item
270//         assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));681        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
271//         assert_noop!(682        assert_noop!(
272//             TemplateModule::burn_item(origin1.clone(), 1, 1),683            TemplateModule::burn_item(origin1.clone(), 1, 1),
273//             "Item does not exists"684            "Item does not exists"
274//         );685        );
275686
276//         assert_eq!(TemplateModule::balance_count((1, 1)), 0);687        assert_eq!(TemplateModule::balance_count(1, 1), 0);
277//     });688    });
278// }689}
279690
280// #[test]691#[test]
281// fn add_collection_admin() {692fn add_collection_admin() {
282//     new_test_ext().execute_with(|| {693    new_test_ext().execute_with(|| {
283//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();694        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
284//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();695        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
285//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();696        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
286697        let mode: CollectionMode = CollectionMode::NFT(2000);
287//         let size = 1024;698
288//         let origin1 = Origin::signed(1);699        let origin1 = Origin::signed(1);
289//         let origin2 = Origin::signed(2);700        let origin2 = Origin::signed(2);
290//         let origin3 = Origin::signed(3);701        let origin3 = Origin::signed(3);
291702        assert_ok!(TemplateModule::create_collection(
292//         assert_ok!(TemplateModule::create_collection(703            origin1.clone(),
293//             origin1.clone(),704            col_name1.clone(),
294//             col_name1.clone(),705            col_desc1.clone(),
295//             col_desc1.clone(),706            token_prefix1.clone(),
296//             token_prefix1.clone(),707            mode.clone()
297//             size708        ));
298//         ));709        assert_ok!(TemplateModule::create_collection(
299//         assert_ok!(TemplateModule::create_collection(710            origin2.clone(),
300//             origin2.clone(),711            col_name1.clone(),
301//             col_name1.clone(),712            col_desc1.clone(),
302//             col_desc1.clone(),713            token_prefix1.clone(),
303//             token_prefix1.clone(),714            mode.clone()
304//             size715        ));
305//         ));716        assert_ok!(TemplateModule::create_collection(
306//         assert_ok!(TemplateModule::create_collection(717            origin3.clone(),
307//             origin3.clone(),718            col_name1.clone(),
308//             col_name1.clone(),719            col_desc1.clone(),
309//             col_desc1.clone(),720            token_prefix1.clone(),
310//             token_prefix1.clone(),721            mode.clone()
311//             size722        ));
312//         ));723
313724        assert_eq!(TemplateModule::collection(1).owner, 1);
314//         assert_eq!(TemplateModule::collection(1).owner, 1);725        assert_eq!(TemplateModule::collection(2).owner, 2);
315//         assert_eq!(TemplateModule::collection(2).owner, 2);726        assert_eq!(TemplateModule::collection(3).owner, 3);
316//         assert_eq!(TemplateModule::collection(3).owner, 3);727
317728        // collection admin
318//         // collection admin729        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
319//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));730        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
320//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));731
321732        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
322//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);733        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
323//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);734    });
324//     });735}
325// }736
326737#[test]
327// #[test]738fn remove_collection_admin() {
328// fn remove_collection_admin() {739    new_test_ext().execute_with(|| {
329//     new_test_ext().execute_with(|| {740        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
330//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();741        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
331//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();742        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
332//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();743        let mode: CollectionMode = CollectionMode::NFT(2000);
333744
334//         let size = 1024;745        let origin1 = Origin::signed(1);
335//         let origin1 = Origin::signed(1);746        let origin2 = Origin::signed(2);
336//         let origin2 = Origin::signed(2);747        let origin3 = Origin::signed(3);
337//         let origin3 = Origin::signed(3);748
338749        assert_ok!(TemplateModule::create_collection(
339//         assert_ok!(TemplateModule::create_collection(750            origin1.clone(),
340//             origin1.clone(),751            col_name1.clone(),
341//             col_name1.clone(),752            col_desc1.clone(),
342//             col_desc1.clone(),753            token_prefix1.clone(),
343//             token_prefix1.clone(),754            mode.clone()
344//             size755        ));
345//         ));756        assert_ok!(TemplateModule::create_collection(
346//         assert_ok!(TemplateModule::create_collection(757            origin2.clone(),
347//             origin2.clone(),758            col_name1.clone(),
348//             col_name1.clone(),759            col_desc1.clone(),
349//             col_desc1.clone(),760            token_prefix1.clone(),
350//             token_prefix1.clone(),761            mode.clone()
351//             size762        ));
352//         ));763        assert_ok!(TemplateModule::create_collection(
353//         assert_ok!(TemplateModule::create_collection(764            origin3.clone(),
354//             origin3.clone(),765            col_name1.clone(),
355//             col_name1.clone(),766            col_desc1.clone(),
356//             col_desc1.clone(),767            token_prefix1.clone(),
357//             token_prefix1.clone(),768            mode.clone()
358//             size769        ));
359//         ));770
360771        assert_eq!(TemplateModule::collection(1).owner, 1);
361//         assert_eq!(TemplateModule::collection(1).owner, 1);772        assert_eq!(TemplateModule::collection(2).owner, 2);
362//         assert_eq!(TemplateModule::collection(2).owner, 2);773        assert_eq!(TemplateModule::collection(3).owner, 3);
363//         assert_eq!(TemplateModule::collection(3).owner, 3);774
364775        // collection admin
365//         // collection admin776        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
366//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));777        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
367//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));778
368779        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
369//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);780        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
370//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);781
371782        // remove admin
372//         // remove admin783        assert_ok!(TemplateModule::remove_collection_admin(
373//         assert_ok!(TemplateModule::remove_collection_admin(784            origin2.clone(),
374//             origin2.clone(),785            1,
375//             1,786            3
376//             3787        ));
377//         ));788        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);
378//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);789    });
379//     });790}
380// }791
381792#[test]
382// #[test]793fn balance_of() {
383// fn balance_of() {794    new_test_ext().execute_with(|| {
384//     new_test_ext().execute_with(|| {795        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
385//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();796        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
386//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();797        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
387//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();798        let nft_mode: CollectionMode = CollectionMode::NFT(2000);
388799        let furg_mode: CollectionMode = CollectionMode::Fungible(3);
389//         let size = 1024;800        let refung_mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
390//         let origin1 = Origin::signed(1);801
391//         let origin2 = Origin::signed(2);802        let origin1 = Origin::signed(1);
392//         let origin3 = Origin::signed(3);803
393804        assert_ok!(TemplateModule::create_collection(
394//         assert_ok!(TemplateModule::create_collection(805            origin1.clone(),
395//             origin1.clone(),806            col_name1.clone(),
396//             col_name1.clone(),807            col_desc1.clone(),
397//             col_desc1.clone(),808            token_prefix1.clone(),
398//             token_prefix1.clone(),809            nft_mode.clone()
399//             size810        ));
400//         ));811        assert_ok!(TemplateModule::create_collection(
401//         assert_ok!(TemplateModule::create_collection(812            origin1.clone(),
402//             origin2.clone(),813            col_name1.clone(),
403//             col_name1.clone(),814            col_desc1.clone(),
404//             col_desc1.clone(),815            token_prefix1.clone(),
405//             token_prefix1.clone(),816            furg_mode.clone()
406//             size817        ));
407//         ));818        assert_ok!(TemplateModule::create_collection(
408//         assert_ok!(TemplateModule::create_collection(819            origin1.clone(),
409//             origin3.clone(),820            col_name1.clone(),
410//             col_name1.clone(),821            col_desc1.clone(),
411//             col_desc1.clone(),822            token_prefix1.clone(),
412//             token_prefix1.clone(),823            refung_mode.clone()
413//             size824        ));
414//         ));825
415826        assert_eq!(TemplateModule::collection(1).owner, 1);
416//         assert_eq!(TemplateModule::collection(1).owner, 1);827        assert_eq!(TemplateModule::collection(2).owner, 1);
417//         assert_eq!(TemplateModule::collection(2).owner, 2);828        assert_eq!(TemplateModule::collection(3).owner, 1);
418//         assert_eq!(TemplateModule::collection(3).owner, 3);829
419830        // check balance before
420//         // check balance before831        assert_eq!(TemplateModule::balance_count(1, 1), 0);
421//         assert_eq!(TemplateModule::balance_count((1, 1)), 0);832        assert_eq!(TemplateModule::balance_count(2, 1), 0);
422833        assert_eq!(TemplateModule::balance_count(3, 1), 0);
423//         // create item834
424//         assert_ok!(TemplateModule::create_item(835        // create item
425//             origin1.clone(),836        assert_ok!(TemplateModule::create_item(
426//             1,837            origin1.clone(),
427//             [1, 1, 1].to_vec()838            1,
428//         ));839            [1, 1, 1].to_vec(),
840            1
841        ));
842
843        assert_ok!(TemplateModule::create_item(
844            origin1.clone(),
845            2,
846            [].to_vec(),
847            1
848        ));
849
850        assert_ok!(TemplateModule::create_item(
851            origin1.clone(),
852            3,
853            [1, 1, 1].to_vec(),
854            1
855        ));
429856
430//         // check balance (collection with id = 1, user id = 2)857        // check balance (collection with id = 1, user id = 1)
431//         assert_eq!(TemplateModule::balance_count((1, 1)), 1);858        assert_eq!(TemplateModule::balance_count(1, 1), 1);
432//         assert_eq!(TemplateModule::item_id((1, 1)).owner, 1);859        assert_eq!(TemplateModule::balance_count(2, 1), 1000);
433//     });860        assert_eq!(TemplateModule::balance_count(3, 1), 1000);
434// }861        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 1);
435862        assert_eq!(TemplateModule::fungible_item_id(2, 1).owner, 1);
436// #[test]863        assert_eq!(TemplateModule::refungible_item_id(3, 1).owner[0].owner, 1);
437// fn transfer() {864    });
438//     new_test_ext().execute_with(|| {865}
439//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();866
440//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();867#[test]
441//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();868fn approve() {
442869    new_test_ext().execute_with(|| {
443//         let size = 1024;870        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
444//         let origin1 = Origin::signed(1);871        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
445//         let origin2 = Origin::signed(2);872        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
446//         let origin3 = Origin::signed(3);873        let nft_mode: CollectionMode = CollectionMode::NFT(2000);
447874        let origin1 = Origin::signed(1);
448//         assert_ok!(TemplateModule::create_collection(875
449//             origin1.clone(),876        assert_ok!(TemplateModule::create_collection(
450//             col_name1.clone(),877            origin1.clone(),
451//             col_desc1.clone(),878            col_name1.clone(),
452//             token_prefix1.clone(),879            col_desc1.clone(),
453//             size880            token_prefix1.clone(),
454//         ));881            nft_mode.clone()
455//         assert_ok!(TemplateModule::create_collection(882        ));
456//             origin2.clone(),883
457//             col_name1.clone(),884        assert_eq!(TemplateModule::collection(1).owner, 1);
458//             col_desc1.clone(),885
459//             token_prefix1.clone(),886        // create item
460//             size887        assert_ok!(TemplateModule::create_item(
461//         ));888            origin1.clone(),
462//         assert_ok!(TemplateModule::create_collection(889            1,
463//             origin3.clone(),890            [1, 1, 1].to_vec(),
464//             col_name1.clone(),891            1
465//             col_desc1.clone(),892        ));
466//             token_prefix1.clone(),893
467//             size
468//         ));
469
470//         assert_eq!(TemplateModule::collection(1).owner, 1);
471//         assert_eq!(TemplateModule::collection(2).owner, 2);
472//         assert_eq!(TemplateModule::collection(3).owner, 3);
473
474//         // create item
475//         assert_ok!(TemplateModule::create_item(
476//             origin1.clone(),
477//             1,
478//             [1, 1, 1].to_vec()
479//         ));
480
481//         // transfer
482//         assert_ok!(TemplateModule::transfer(origin1.clone(), 1, 1, 2));
483//         assert_eq!(TemplateModule::item_id((1, 1)).owner, 2);
484
485//         // balance_of check
486//         assert_eq!(TemplateModule::balance_count((1, 1)), 0);
487//         assert_eq!(TemplateModule::balance_count((1, 2)), 1);
488//     });
489// }
490
491// #[test]
492// fn approve() {894        // approve
493//     new_test_ext().execute_with(|| {895        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
494//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();896        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
495//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();897    });
496//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();898}
497899
498//         let size = 1024;900#[test]
499//         let origin1 = Origin::signed(1);901fn transfer_from() {
500//         let origin2 = Origin::signed(2);902    new_test_ext().execute_with(|| {
501//         let origin3 = Origin::signed(3);903        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
502904        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
503//         assert_ok!(TemplateModule::create_collection(905        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
504//             origin1.clone(),906        let mode: CollectionMode = CollectionMode::NFT(2000);
505//             col_name1.clone(),907        let origin1 = Origin::signed(1);
506//             col_desc1.clone(),908        let origin2 = Origin::signed(2);
507//             token_prefix1.clone(),909
508//             size910        assert_ok!(TemplateModule::create_collection(
509//         ));911            origin1.clone(),
510//         assert_ok!(TemplateModule::create_collection(912            col_name1.clone(),
511//             origin2.clone(),913            col_desc1.clone(),
512//             col_name1.clone(),914            token_prefix1.clone(),
513//             col_desc1.clone(),915            mode
514//             token_prefix1.clone(),916        ));
515//             size917
516//         ));918        assert_eq!(TemplateModule::collection(1).owner, 1);
517//         assert_ok!(TemplateModule::create_collection(919
518//             origin3.clone(),920        // create item
519//             col_name1.clone(),921        assert_ok!(TemplateModule::create_item(
520//             col_desc1.clone(),922            origin1.clone(),
521//             token_prefix1.clone(),923            1,
522//             size924            [1, 1, 1].to_vec(),
523//         ));925            1
524926        ));
525//         assert_eq!(TemplateModule::collection(1).owner, 1);927
526//         assert_eq!(TemplateModule::collection(2).owner, 2);928        // approve
527//         assert_eq!(TemplateModule::collection(3).owner, 3);929        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
528930        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
529//         // create item931        assert_ok!(TemplateModule::transfer_from(
530//         assert_ok!(TemplateModule::create_item(932            origin2.clone(),
531//             origin1.clone(),933            1,
532//             1,934            2,
533//             [1, 1, 1].to_vec()935            1,
534//         ));936            1,
535937            1
536//         // approve938        ));
537//         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));939
538//         assert_eq!(TemplateModule::approved((1, 1)).contains(&2), true);940        // after transfer
539//     });941        assert_eq!(TemplateModule::balance_count(1, 1), 0);
540// }942        assert_eq!(TemplateModule::balance_count(1, 2), 1);
541943    });
542// #[test]944}
543// fn get_approved() {
544//     new_test_ext().execute_with(|| {
545//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
546//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
547//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
548
549//         let size = 1024;
550//         let origin1 = Origin::signed(1);
551//         let origin2 = Origin::signed(2);
552//         let origin3 = Origin::signed(3);
553
554//         assert_ok!(TemplateModule::create_collection(
555//             origin1.clone(),
556//             col_name1.clone(),
557//             col_desc1.clone(),
558//             token_prefix1.clone(),
559//             size
560//         ));
561//         assert_ok!(TemplateModule::create_collection(
562//             origin2.clone(),
563//             col_name1.clone(),
564//             col_desc1.clone(),
565//             token_prefix1.clone(),
566//             size
567//         ));
568//         assert_ok!(TemplateModule::create_collection(
569//             origin3.clone(),
570//             col_name1.clone(),
571//             col_desc1.clone(),
572//             token_prefix1.clone(),
573//             size
574//         ));
575
576//         assert_eq!(TemplateModule::collection(1).owner, 1);
577//         assert_eq!(TemplateModule::collection(2).owner, 2);
578//         assert_eq!(TemplateModule::collection(3).owner, 3);
579
580//         // create item
581//         assert_ok!(TemplateModule::create_item(
582//             origin1.clone(),
583//             1,
584//             [1, 1, 1].to_vec()
585//         ));
586
587//         // approve
588//         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
589//         assert_eq!(TemplateModule::approved((1, 1)).contains(&2), true);
590//     });
591// }
592
593// #[test]
594// fn transfer_from() {
595//     new_test_ext().execute_with(|| {
596//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
597//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
598//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
599
600//         let size = 1024;
601//         let origin1 = Origin::signed(1);
602//         let origin2 = Origin::signed(2);
603//         let origin3 = Origin::signed(3);
604
605//         assert_ok!(TemplateModule::create_collection(
606//             origin1.clone(),
607//             col_name1.clone(),
608//             col_desc1.clone(),
609//             token_prefix1.clone(),
610//             size
611//         ));
612//         assert_ok!(TemplateModule::create_collection(
613//             origin2.clone(),
614//             col_name1.clone(),
615//             col_desc1.clone(),
616//             token_prefix1.clone(),
617//             size
618//         ));
619//         assert_ok!(TemplateModule::create_collection(
620//             origin3.clone(),
621//             col_name1.clone(),
622//             col_desc1.clone(),
623//             token_prefix1.clone(),
624//             size
625//         ));
626
627//         assert_eq!(TemplateModule::collection(1).owner, 1);
628//         assert_eq!(TemplateModule::collection(2).owner, 2);
629//         assert_eq!(TemplateModule::collection(3).owner, 3);
630
631//         // create item
632//         assert_ok!(TemplateModule::create_item(
633//             origin1.clone(),
634//             1,
635//             [1, 1, 1].to_vec()
636//         ));
637
638//         // approve
639//         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
640//         assert_ok!(TemplateModule::transfer_from(origin1.clone(), 1, 1, 2));
641//     });
642// }
643
644// #[test]
645// fn index_list() {
646//     new_test_ext().execute_with(|| {
647//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
648//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
649//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
650
651//         let size = 1024;
652//         let origin1 = Origin::signed(1);
653//         let origin2 = Origin::signed(2);
654//         let origin3 = Origin::signed(3);
655
656//         assert_ok!(TemplateModule::create_collection(
657//             origin1.clone(),
658//             col_name1.clone(),
659//             col_desc1.clone(),
660//             token_prefix1.clone(),
661//             size
662//         ));
663//         assert_ok!(TemplateModule::create_collection(
664//             origin2.clone(),
665//             col_name1.clone(),
666//             col_desc1.clone(),
667//             token_prefix1.clone(),
668//             size
669//         ));
670//         assert_ok!(TemplateModule::create_collection(
671//             origin3.clone(),
672//             col_name1.clone(),
673//             col_desc1.clone(),
674//             token_prefix1.clone(),
675//             size
676//         ));
677
678//         assert_eq!(TemplateModule::collection(1).owner, 1);
679//         assert_eq!(TemplateModule::collection(2).owner, 2);
680//         assert_eq!(TemplateModule::collection(3).owner, 3);
681//         // create items
682//         assert_ok!(TemplateModule::create_item(
683//             origin1.clone(),
684//             1,
685//             [1, 1, 1].to_vec()
686//         ));
687//         assert_ok!(TemplateModule::create_item(
688//             origin1.clone(),
689//             1,
690//             [1, 1, 2].to_vec()
691//         ));
692//         assert_ok!(TemplateModule::create_item(
693//             origin1.clone(),
694//             1,
695//             [1, 2, 3].to_vec()
696//         ));
697//         assert_eq!(TemplateModule::address_tokens((1, 1)).len(), 3);
698//         // burn one
699//         assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 2));
700//         assert_eq!(TemplateModule::address_tokens((1, 1)).len(), 2);
701//         // burn another one
702//         assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 3));
703//         assert_eq!(TemplateModule::address_tokens((1, 1))[0], 1);
704//     });
705// }
706945