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

--- a/README.md
+++ b/README.md
@@ -171,6 +171,20 @@
       "ReFungible": "(u32, u32)"
     }
   },
+  "Ownership": {
+    "Owner": "AccountId",
+    "Fraction": "u128"
+  },
+  "FungibleItemType": {
+    "Collection": "u64",
+    "Owner": "AccountId",
+    "Value": "u128"
+  },
+  "ReFungibleItemType": {
+    "Collection": "u64",
+    "Owner": "Vec<Ownership>",
+    "Data": "Vec<u8>"
+  },
   "NftItemType": {
     "Collection": "u64",
     "Owner": "AccountId",

--- a/node/src/cli.rs
+++ b/node/src/cli.rs
@@ -3,9 +3,9 @@
 
 #[derive(Debug, StructOpt)]
 pub struct Cli {
-	#[structopt(subcommand)]
-	pub subcommand: Option<Subcommand>,
+    #[structopt(subcommand)]
+    pub subcommand: Option<Subcommand>,
 
-	#[structopt(flatten)]
-	pub run: RunCmd,
+    #[structopt(flatten)]
+    pub run: RunCmd,
 }

--- a/node/src/command.rs
+++ b/node/src/command.rs
@@ -21,61 +21,57 @@
 use sc_cli::SubstrateCli;
 
 impl SubstrateCli for Cli {
-	fn impl_name() -> &'static str {
-		"Substrate Node"
-	}
+    fn impl_name() -> &'static str {
+        "Substrate Node"
+    }
 
-	fn impl_version() -> &'static str {
-		env!("SUBSTRATE_CLI_IMPL_VERSION")
-	}
+    fn impl_version() -> &'static str {
+        env!("SUBSTRATE_CLI_IMPL_VERSION")
+    }
 
-	fn description() -> &'static str {
-		env!("CARGO_PKG_DESCRIPTION")
-	}
+    fn description() -> &'static str {
+        env!("CARGO_PKG_DESCRIPTION")
+    }
 
-	fn author() -> &'static str {
-		env!("CARGO_PKG_AUTHORS")
-	}
+    fn author() -> &'static str {
+        env!("CARGO_PKG_AUTHORS")
+    }
 
-	fn support_url() -> &'static str {
-		"support.anonymous.an"
-	}
+    fn support_url() -> &'static str {
+        "support.anonymous.an"
+    }
 
-	fn copyright_start_year() -> i32 {
-		2017
-	}
+    fn copyright_start_year() -> i32 {
+        2017
+    }
 
-	fn executable_name() -> &'static str {
-		env!("CARGO_PKG_NAME")
-	}
+    fn executable_name() -> &'static str {
+        env!("CARGO_PKG_NAME")
+    }
 
-	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
-		Ok(match id {
-			"dev" => Box::new(chain_spec::development_config()),
-			"" | "local" => Box::new(chain_spec::local_testnet_config()),
-			path => Box::new(chain_spec::ChainSpec::from_json_file(
-				std::path::PathBuf::from(path),
-			)?),
-		})
-	}
+    fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+        Ok(match id {
+            "dev" => Box::new(chain_spec::development_config()),
+            "" | "local" => Box::new(chain_spec::local_testnet_config()),
+            path => Box::new(chain_spec::ChainSpec::from_json_file(
+                std::path::PathBuf::from(path),
+            )?),
+        })
+    }
 }
 
 /// Parse and run command line arguments
 pub fn run() -> sc_cli::Result<()> {
-	let cli = Cli::from_args();
+    let cli = Cli::from_args();
 
-	match &cli.subcommand {
-		Some(subcommand) => {
-			let runner = cli.create_runner(subcommand)?;
-			runner.run_subcommand(subcommand, |config| Ok(new_full_start!(config).0))
-		}
-		None => {
-			let runner = cli.create_runner(&cli.run)?;
-			runner.run_node(
-				service::new_light,
-				service::new_full,
-				nft_runtime::VERSION
-			)
-		}
-	}
-}
\ No newline at end of file
+    match &cli.subcommand {
+        Some(subcommand) => {
+            let runner = cli.create_runner(subcommand)?;
+            runner.run_subcommand(subcommand, |config| Ok(new_full_start!(config).0))
+        }
+        None => {
+            let runner = cli.create_runner(&cli.run)?;
+            runner.run_node(service::new_light, service::new_full, nft_runtime::VERSION)
+        }
+    }
+}

--- a/node/src/main.rs
+++ b/node/src/main.rs
@@ -8,5 +8,5 @@
 mod command;
 
 fn main() -> sc_cli::Result<()> {
-	command::run()
+    command::run()
 }

--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -188,7 +188,7 @@
             prometheus_registry: service.prometheus_registry(),
             shared_voter_state: SharedVoterState::empty(),
         };
-        
+
         // the GRANDPA voter task is considered infallible, i.e.
         // if it fails we take down the service with it.
         service.spawn_essential_task_handle().spawn_blocking(

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

--- a/pallets/nft/src/mock.rs
+++ b/pallets/nft/src/mock.rs
@@ -1,19 +1,19 @@
 // Creating mock runtime here
 
 use crate::{Module, Trait};
+use frame_support::{
+    impl_outer_origin, parameter_types,
+    weights::{
+        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight},
+        Weight,
+    },
+};
 use frame_system as system;
 use sp_core::H256;
 use sp_runtime::{
     testing::Header,
     traits::{BlakeTwo256, IdentityLookup, Saturating},
     Perbill,
-};
-use frame_support::{
-    parameter_types, impl_outer_origin,
-    weights::{
-        constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight},
-        Weight,
-    },
 };
 
 impl_outer_origin! {
@@ -49,9 +49,9 @@
     type MaximumBlockWeight = MaximumBlockWeight;
     type MaximumBlockLength = MaximumBlockLength;
     type AvailableBlockRatio = AvailableBlockRatio;
-    type BaseCallFilter = (); 
-    type DbWeight = RocksDbWeight; 
-    type BlockExecutionWeight = BlockExecutionWeight; 
+    type BaseCallFilter = ();
+    type DbWeight = RocksDbWeight;
+    type BlockExecutionWeight = BlockExecutionWeight;
     type ExtrinsicBaseWeight = ExtrinsicBaseWeight;
     type MaximumExtrinsicWeight = MaximumExtrinsicWeight;
     type Version = ();

--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -1,6 +1,6 @@
 // Tests to be written here
 use crate::mock::*;
-use crate::{CollectionMode, Ownership};
+use crate::{ApprovePermissions, CollectionMode, Ownership};
 use frame_support::{assert_noop, assert_ok};
 
 #[test]
@@ -21,9 +21,13 @@
         ));
         assert_eq!(TemplateModule::collection(1).owner, 1);
 
-
-        assert_ok!(TemplateModule::create_item(origin1.clone(), 1, [1,2,3].to_vec(), 1));
-        assert_eq!(TemplateModule::nft_item_id(1,1).data, [1,2,3].to_vec());
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
     });
 }
 
@@ -45,10 +49,111 @@
         ));
         assert_eq!(TemplateModule::collection(1).owner, 1);
 
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).data,
+            [1, 2, 3].to_vec()
+        );
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[0],
+            Ownership {
+                owner: 1,
+                fraction: 1000
+            }
+        );
+    });
+}
+
+#[test]
+fn create_fungible_item() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::Fungible(3);
+
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_eq!(TemplateModule::collection(1).owner, 1);
+
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [].to_vec(),
+            1
+        ));
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+    });
+}
+
+#[test]
+fn transfer_fungible_item() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::Fungible(3);
+
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_eq!(TemplateModule::collection(1).owner, 1);
+
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [].to_vec(),
+            1
+        ));
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+
+        // change owner scenario
+        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+        assert_eq!(TemplateModule::balance_count(1, 2), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), []);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
 
-        assert_ok!(TemplateModule::create_item(origin1.clone(), 1, [1,2,3].to_vec(), 1));
-        assert_eq!(TemplateModule::refungible_item_id(1,1).data, [1,2,3].to_vec());
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[0], Ownership { owner: 1, fraction: 1000 });
+        // split item scenario
+        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
+        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);
+        assert_eq!(TemplateModule::balance_count(1, 2), 500);
+        assert_eq!(TemplateModule::balance_count(1, 3), 500);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
+
+        // split item and new owner has account scenario
+        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);
+        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);
+        assert_eq!(TemplateModule::balance_count(1, 2), 300);
+        assert_eq!(TemplateModule::balance_count(1, 3), 700);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
     });
 }
 
@@ -71,40 +176,83 @@
         ));
         assert_eq!(TemplateModule::collection(1).owner, 1);
 
-        assert_ok!(TemplateModule::create_item(origin1.clone(), 1, [1,2,3].to_vec(), 1));
-        assert_eq!(TemplateModule::refungible_item_id(1,1).data, [1,2,3].to_vec());
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[0], Ownership { owner: 1, fraction: 1000 });
-        assert_eq!(TemplateModule::balance_count(1,1), 1000);
-        assert_eq!(TemplateModule::address_tokens(1,1), [1]);
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).data,
+            [1, 2, 3].to_vec()
+        );
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[0],
+            Ownership {
+                owner: 1,
+                fraction: 1000
+            }
+        );
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
         // change owner scenario
         assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[0], Ownership { owner: 2, fraction: 1000 });
-        assert_eq!(TemplateModule::balance_count(1,1), 0);
-        assert_eq!(TemplateModule::balance_count(1,2), 1000);
-        assert_eq!(TemplateModule::address_tokens(1,1), []);
-        assert_eq!(TemplateModule::address_tokens(1,2), [1]);
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[0],
+            Ownership {
+                owner: 2,
+                fraction: 1000
+            }
+        );
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+        assert_eq!(TemplateModule::balance_count(1, 2), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), []);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
 
         // split item scenario
         assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[0], Ownership { owner: 2, fraction: 500 });
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[1], Ownership { owner: 3, fraction: 500 });
-        assert_eq!(TemplateModule::balance_count(1,2), 500);
-        assert_eq!(TemplateModule::balance_count(1,3), 500);
-        assert_eq!(TemplateModule::address_tokens(1,2), [1]);
-        assert_eq!(TemplateModule::address_tokens(1,3), [1]);
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[0],
+            Ownership {
+                owner: 2,
+                fraction: 500
+            }
+        );
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[1],
+            Ownership {
+                owner: 3,
+                fraction: 500
+            }
+        );
+        assert_eq!(TemplateModule::balance_count(1, 2), 500);
+        assert_eq!(TemplateModule::balance_count(1, 3), 500);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);
 
         // split item and new owner has account scenario
         assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[0], Ownership { owner: 2, fraction: 300 });
-        assert_eq!(TemplateModule::refungible_item_id(1,1).owner[1], Ownership { owner: 3, fraction: 700 });
-        assert_eq!(TemplateModule::balance_count(1,2), 300);
-        assert_eq!(TemplateModule::balance_count(1,3), 700);
-        assert_eq!(TemplateModule::address_tokens(1,2), [1]);
-        assert_eq!(TemplateModule::address_tokens(1,3), [1]);
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[0],
+            Ownership {
+                owner: 2,
+                fraction: 300
+            }
+        );
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[1],
+            Ownership {
+                owner: 3,
+                fraction: 700
+            }
+        );
+        assert_eq!(TemplateModule::balance_count(1, 2), 300);
+        assert_eq!(TemplateModule::balance_count(1, 3), 700);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);
     });
 }
-
 
 #[test]
 fn transfer_nft_item() {
@@ -124,582 +272,673 @@
         ));
         assert_eq!(TemplateModule::collection(1).owner, 1);
 
-
-        assert_ok!(TemplateModule::create_item(origin1.clone(), 1, [1,2,3].to_vec(), 1));
-        assert_eq!(TemplateModule::nft_item_id(1,1).data, [1,2,3].to_vec());
-        assert_eq!(TemplateModule::balance_count(1,1), 1);
-        assert_eq!(TemplateModule::address_tokens(1,1), [1]);
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
+        assert_eq!(TemplateModule::balance_count(1, 1), 1);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
         // default scenario
         assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));
-        assert_eq!(TemplateModule::nft_item_id(1,1).owner, 2);
-        assert_eq!(TemplateModule::balance_count(1,1), 0);
-        assert_eq!(TemplateModule::balance_count(1,2), 1);
-        assert_eq!(TemplateModule::address_tokens(1,1), []);
-        assert_eq!(TemplateModule::address_tokens(1,2), [1]); 
+        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 2);
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+        assert_eq!(TemplateModule::balance_count(1, 2), 1);
+        assert_eq!(TemplateModule::address_tokens(1, 1), []);
+        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
     });
 }
 
+#[test]
+fn nft_approve_and_transfer_from() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
 
-// #[test]
-// fn create_collection_test() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//     });
-// }
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
+        assert_eq!(TemplateModule::balance_count(1, 1), 1);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
-// #[test]
-// fn change_collection_owner() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        assert_noop!(
+            TemplateModule::transfer_from(origin2.clone(), 1, 3, 1, 1, 1),
+            "You do not have permissions to modify this collection"
+        );
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
+        // do approve
+        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
+        assert_ok!(TemplateModule::approve(origin1.clone(), 10, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);
+        assert_eq!(
+            TemplateModule::approved(1, (1, 1))[0],
+            ApprovePermissions {
+                approved: 2,
+                amount: 100000000
+            }
+        );
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::change_collection_owner(
-//             origin1.clone(),
-//             1,
-//             2
-//         ));
-//         assert_eq!(TemplateModule::collection(1).owner, 2);
-//     });
-// }
+        assert_ok!(TemplateModule::transfer_from(
+            origin2.clone(),
+            1,
+            3,
+            1,
+            1,
+            1
+        ));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);
+    });
+}
 
-// #[test]
-// fn destroy_collection() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+#[test]
+fn refungible_approve_and_transfer_from() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
-//     });
-// }
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).data,
+            [1, 2, 3].to_vec()
+        );
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).owner[0],
+            Ownership {
+                owner: 1,
+                fraction: 1000
+            }
+        );
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
-// #[test]
-// fn create_item() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        assert_noop!(
+            TemplateModule::transfer_from(origin2.clone(), 1, 3, 1, 1, 1),
+            "You do not have permissions to modify this collection"
+        );
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
+        // do approve
+        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
+        assert_ok!(TemplateModule::approve(origin1.clone(), 10, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);
+        assert_eq!(
+            TemplateModule::approved(1, (1, 1))[0],
+            ApprovePermissions {
+                approved: 2,
+                amount: 100000000
+            }
+        );
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-//         assert_ok!(TemplateModule::create_item(
-//             origin2.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+        assert_ok!(TemplateModule::transfer_from(
+            origin2.clone(),
+            1,
+            3,
+            1,
+            1,
+            100
+        ));
+        assert_eq!(TemplateModule::balance_count(1, 1), 900);
+        assert_eq!(TemplateModule::balance_count(1, 3), 100);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);
 
-//         // check balance (collection with id = 1, user id = 2)
-//         assert_eq!(TemplateModule::balance_count((1, 2)), 1);
-//     });
-// }
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
+        assert_eq!(
+            TemplateModule::approved(1, (1, 1))[0],
+            ApprovePermissions {
+                approved: 10,
+                amount: 100000000
+            }
+        );
+    });
+}
 
-// #[test]
-// fn burn_item() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+#[test]
+fn fungible_approve_and_transfer_from() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::Fungible(3);
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-//         assert_ok!(TemplateModule::create_item(
-//             origin2.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [].to_vec(),
+            1
+        ));
+        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
 
-//         // check balance (collection with id = 1, user id = 2)
-//         assert_eq!(TemplateModule::balance_count((1, 2)), 1);
+        assert_noop!(
+            TemplateModule::transfer_from(origin2.clone(), 1, 3, 1, 1, 1),
+            "You do not have permissions to modify this collection"
+        );
 
-//         // burn item
-//         assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
-//         assert_noop!(
-//             TemplateModule::burn_item(origin1.clone(), 1, 1),
-//             "Item does not exists"
-//         );
+        // do approve
+        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
+        assert_ok!(TemplateModule::approve(origin1.clone(), 10, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);
+        assert_eq!(
+            TemplateModule::approved(1, (1, 1))[0],
+            ApprovePermissions {
+                approved: 2,
+                amount: 100000000
+            }
+        );
 
-//         assert_eq!(TemplateModule::balance_count((1, 1)), 0);
-//     });
-// }
+        assert_ok!(TemplateModule::transfer_from(
+            origin2.clone(),
+            1,
+            3,
+            1,
+            1,
+            100
+        ));
+        assert_eq!(TemplateModule::balance_count(1, 1), 900);
+        assert_eq!(TemplateModule::balance_count(1, 3), 100);
+        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
 
-// #[test]
-// fn add_collection_admin() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);
+        assert_eq!(
+            TemplateModule::approved(1, (1, 1))[0],
+            ApprovePermissions {
+                approved: 10,
+                amount: 100000000
+            }
+        );
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
+        assert_ok!(TemplateModule::transfer_from(
+            origin2.clone(),
+            1,
+            3,
+            1,
+            1,
+            900
+        ));
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+        assert_eq!(TemplateModule::balance_count(1, 3), 1000);
+        assert_eq!(TemplateModule::address_tokens(1, 1), []);
+        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);
+    });
+}
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+#[test]
+fn change_collection_owner() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
 
-//         // collection admin
-//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_ok!(TemplateModule::change_collection_owner(
+            origin1.clone(),
+            1,
+            2
+        ));
+        assert_eq!(TemplateModule::collection(1).owner, 2);
+    });
+}
 
-//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
-//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
-//     });
-// }
+#[test]
+fn destroy_collection() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
 
-// #[test]
-// fn remove_collection_admin() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let origin1 = Origin::signed(1);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_ok!(TemplateModule::destroy_collection(origin1.clone(), 1));
+    });
+}
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+#[test]
+fn burn_nft_item() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::create_item(
+            origin2.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+        assert_eq!(TemplateModule::nft_item_id(1, 1).data, [1, 2, 3].to_vec());
 
-//         // collection admin
-//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
-//         assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
+        // check balance (collection with id = 1, user id = 1)
+        assert_eq!(TemplateModule::balance_count(1, 1), 1);
 
-//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
-//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
+        // burn item
+        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
+        assert_noop!(
+            TemplateModule::burn_item(origin1.clone(), 1, 1),
+            "Item does not exists"
+        );
 
-//         // remove admin
-//         assert_ok!(TemplateModule::remove_collection_admin(
-//             origin2.clone(),
-//             1,
-//             3
-//         ));
-//         assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);
-//     });
-// }
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+    });
+}
 
-// #[test]
-// fn balance_of() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+#[test]
+fn burn_fungible_item() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::Fungible(3);
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::create_item(
+            origin2.clone(),
+            1,
+            [].to_vec(),
+            1
+        ));
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        // check balance (collection with id = 1, user id = 1)
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+        // burn item
+        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
+        assert_noop!(
+            TemplateModule::burn_item(origin1.clone(), 1, 1),
+            "Item does not exists"
+        );
 
-//         // check balance before
-//         assert_eq!(TemplateModule::balance_count((1, 1)), 0);
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+    });
+}
 
-//         // create item
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+#[test]
+fn burn_refungible_item() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::ReFungible(200, 3);
 
-//         // check balance (collection with id = 1, user id = 2)
-//         assert_eq!(TemplateModule::balance_count((1, 1)), 1);
-//         assert_eq!(TemplateModule::item_id((1, 1)).owner, 1);
-//     });
-// }
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::create_item(
+            origin2.clone(),
+            1,
+            [1, 2, 3].to_vec(),
+            1
+        ));
 
-// #[test]
-// fn transfer() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        assert_eq!(
+            TemplateModule::refungible_item_id(1, 1).data,
+            [1, 2, 3].to_vec()
+        );
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        // check balance (collection with id = 1, user id = 2)
+        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        // burn item
+        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));
+        assert_noop!(
+            TemplateModule::burn_item(origin1.clone(), 1, 1),
+            "Item does not exists"
+        );
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+    });
+}
 
-//         // create item
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+#[test]
+fn add_collection_admin() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
 
-//         // transfer
-//         assert_ok!(TemplateModule::transfer(origin1.clone(), 1, 1, 2));
-//         assert_eq!(TemplateModule::item_id((1, 1)).owner, 2);
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        let origin3 = Origin::signed(3);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ));
+        assert_ok!(TemplateModule::create_collection(
+            origin2.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ));
+        assert_ok!(TemplateModule::create_collection(
+            origin3.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ));
 
-//         // balance_of check
-//         assert_eq!(TemplateModule::balance_count((1, 1)), 0);
-//         assert_eq!(TemplateModule::balance_count((1, 2)), 1);
-//     });
-// }
+        assert_eq!(TemplateModule::collection(1).owner, 1);
+        assert_eq!(TemplateModule::collection(2).owner, 2);
+        assert_eq!(TemplateModule::collection(3).owner, 3);
 
-// #[test]
-// fn approve() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        // collection admin
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
+        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
+    });
+}
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+#[test]
+fn remove_collection_admin() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+        let origin3 = Origin::signed(3);
 
-//         // create item
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ));
+        assert_ok!(TemplateModule::create_collection(
+            origin2.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ));
+        assert_ok!(TemplateModule::create_collection(
+            origin3.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode.clone()
+        ));
 
-//         // approve
-//         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
-//         assert_eq!(TemplateModule::approved((1, 1)).contains(&2), true);
-//     });
-// }
+        assert_eq!(TemplateModule::collection(1).owner, 1);
+        assert_eq!(TemplateModule::collection(2).owner, 2);
+        assert_eq!(TemplateModule::collection(3).owner, 3);
 
-// #[test]
-// fn get_approved() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        // collection admin
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 2));
+        assert_ok!(TemplateModule::add_collection_admin(origin1.clone(), 1, 3));
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        assert_eq!(TemplateModule::admin_list_collection(1).contains(&2), true);
+        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), true);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        // remove admin
+        assert_ok!(TemplateModule::remove_collection_admin(
+            origin2.clone(),
+            1,
+            3
+        ));
+        assert_eq!(TemplateModule::admin_list_collection(1).contains(&3), false);
+    });
+}
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+#[test]
+fn balance_of() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let nft_mode: CollectionMode = CollectionMode::NFT(2000);
+        let furg_mode: CollectionMode = CollectionMode::Fungible(3);
+        let refung_mode: CollectionMode = CollectionMode::ReFungible(2000, 3);
 
-//         // create item
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+        let origin1 = Origin::signed(1);
 
-//         // approve
-//         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
-//         assert_eq!(TemplateModule::approved((1, 1)).contains(&2), true);
-//     });
-// }
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            nft_mode.clone()
+        ));
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            furg_mode.clone()
+        ));
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            refung_mode.clone()
+        ));
 
-// #[test]
-// fn transfer_from() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        assert_eq!(TemplateModule::collection(1).owner, 1);
+        assert_eq!(TemplateModule::collection(2).owner, 1);
+        assert_eq!(TemplateModule::collection(3).owner, 1);
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        // check balance before
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+        assert_eq!(TemplateModule::balance_count(2, 1), 0);
+        assert_eq!(TemplateModule::balance_count(3, 1), 0);
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        // create item
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 1, 1].to_vec(),
+            1
+        ));
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            2,
+            [].to_vec(),
+            1
+        ));
 
-//         // create item
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            3,
+            [1, 1, 1].to_vec(),
+            1
+        ));
 
-//         // approve
-//         assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
-//         assert_ok!(TemplateModule::transfer_from(origin1.clone(), 1, 1, 2));
-//     });
-// }
+        // check balance (collection with id = 1, user id = 1)
+        assert_eq!(TemplateModule::balance_count(1, 1), 1);
+        assert_eq!(TemplateModule::balance_count(2, 1), 1000);
+        assert_eq!(TemplateModule::balance_count(3, 1), 1000);
+        assert_eq!(TemplateModule::nft_item_id(1, 1).owner, 1);
+        assert_eq!(TemplateModule::fungible_item_id(2, 1).owner, 1);
+        assert_eq!(TemplateModule::refungible_item_id(3, 1).owner[0].owner, 1);
+    });
+}
 
-// #[test]
-// fn index_list() {
-//     new_test_ext().execute_with(|| {
-//         let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
-//         let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
-//         let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+#[test]
+fn approve() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let nft_mode: CollectionMode = CollectionMode::NFT(2000);
+        let origin1 = Origin::signed(1);
 
-//         let size = 1024;
-//         let origin1 = Origin::signed(1);
-//         let origin2 = Origin::signed(2);
-//         let origin3 = Origin::signed(3);
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            nft_mode.clone()
+        ));
 
-//         assert_ok!(TemplateModule::create_collection(
-//             origin1.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin2.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
-//         assert_ok!(TemplateModule::create_collection(
-//             origin3.clone(),
-//             col_name1.clone(),
-//             col_desc1.clone(),
-//             token_prefix1.clone(),
-//             size
-//         ));
+        assert_eq!(TemplateModule::collection(1).owner, 1);
 
-//         assert_eq!(TemplateModule::collection(1).owner, 1);
-//         assert_eq!(TemplateModule::collection(2).owner, 2);
-//         assert_eq!(TemplateModule::collection(3).owner, 3);
-//         // create items
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 1].to_vec()
-//         ));
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 1, 2].to_vec()
-//         ));
-//         assert_ok!(TemplateModule::create_item(
-//             origin1.clone(),
-//             1,
-//             [1, 2, 3].to_vec()
-//         ));
-//         assert_eq!(TemplateModule::address_tokens((1, 1)).len(), 3);
-//         // burn one
-//         assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 2));
-//         assert_eq!(TemplateModule::address_tokens((1, 1)).len(), 2);
-//         // burn another one
-//         assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 3));
-//         assert_eq!(TemplateModule::address_tokens((1, 1))[0], 1);
-//     });
-// }
+        // create item
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 1, 1].to_vec(),
+            1
+        ));
+
+        // approve
+        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
+    });
+}
+
+#[test]
+fn transfer_from() {
+    new_test_ext().execute_with(|| {
+        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();
+        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();
+        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
+        let mode: CollectionMode = CollectionMode::NFT(2000);
+        let origin1 = Origin::signed(1);
+        let origin2 = Origin::signed(2);
+
+        assert_ok!(TemplateModule::create_collection(
+            origin1.clone(),
+            col_name1.clone(),
+            col_desc1.clone(),
+            token_prefix1.clone(),
+            mode
+        ));
+
+        assert_eq!(TemplateModule::collection(1).owner, 1);
+
+        // create item
+        assert_ok!(TemplateModule::create_item(
+            origin1.clone(),
+            1,
+            [1, 1, 1].to_vec(),
+            1
+        ));
+
+        // approve
+        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));
+        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);
+        assert_ok!(TemplateModule::transfer_from(
+            origin2.clone(),
+            1,
+            2,
+            1,
+            1,
+            1
+        ));
+
+        // after transfer
+        assert_eq!(TemplateModule::balance_count(1, 1), 0);
+        assert_eq!(TemplateModule::balance_count(1, 2), 1);
+    });
+}