git.delta.rocks / unique-network / refs/commits / 9ecb329aa0c0

difftreelog

Merge remote-tracking branch 'origin/develop' into feature/NFTPAR-241

kpozdnikin2021-01-18parents: #f4eeb2e #07025d8.patch.diff
in: master
# Conflicts:
#	tests/package.json

16 files changed

modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -1153,7 +1153,7 @@
             }
 
             // Reduce approval by transferred amount or remove if remaining approval drops to 0
-            if approval - value > 0 {
+            if approval.checked_sub(value).unwrap_or(0) > 0 {
                 <Allowances<T>>::insert(collection_id, (item_id, &from, &recipient), approval - value);
             }
             else {
modifiedpallets/nft/src/tests.rsdiffbeforeafterboth
1// Tests to be written here1// Tests to be written here
2use super::*;2use super::*;
3use crate::mock::*;3use crate::mock::*;
4use crate::{AccessMode, ApprovePermissions, CollectionMode,4use crate::{AccessMode, CollectionMode,
5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,5    Ownership, ChainLimits, CreateItemData, CreateNftData, CreateFungibleData, CreateReFungibleData,
6    CollectionId, TokenId, MAX_DECIMAL_POINTS};6    CollectionId, TokenId, MAX_DECIMAL_POINTS};
7use frame_support::{assert_noop, assert_ok};7use frame_support::{assert_noop, assert_ok};
28}28}
2929
30fn default_fungible_data () -> CreateFungibleData {30fn default_fungible_data () -> CreateFungibleData {
31    CreateFungibleData { }31    CreateFungibleData { value: 5 }
32}32}
3333
34fn default_re_fungible_data () -> CreateReFungibleData {34fn default_re_fungible_data () -> CreateReFungibleData {
238        let data = default_fungible_data();238        let data = default_fungible_data();
239        create_test_item(collection_id, &data.into());239        create_test_item(collection_id, &data.into());
240240
241        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).owner, 1);241        assert_eq!(TemplateModule::fungible_item_id(collection_id, 1).value, 5);
242    });242    });
243}243}
244244
245#[test]245//#[test]
246fn create_multiple_fungible_items() {246// fn create_multiple_fungible_items() {
247    new_test_ext().execute_with(|| {247//     new_test_ext().execute_with(|| {
248        default_limits();248//         default_limits();
249249
250        create_test_collection(&CollectionMode::Fungible(3), 1);250//         create_test_collection(&CollectionMode::Fungible(3), 1);
251251
252        let origin1 = Origin::signed(1);252//         let origin1 = Origin::signed(1);
253253
254        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];254//         let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];
255255
256        assert_ok!(TemplateModule::create_multiple_items(256//         assert_ok!(TemplateModule::create_multiple_items(
257            origin1.clone(),257//             origin1.clone(),
258            1,258//             1,
259            1,259//             1,
260            items_data.clone().into_iter().map(|d| { d.into() }).collect()260//             items_data.clone().into_iter().map(|d| { d.into() }).collect()
261        ));261//         ));
262        262        
263        for (index, _) in items_data.iter().enumerate() {263//         for (index, _) in items_data.iter().enumerate() {
264            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).owner, 1);264//             assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as TokenId).value, 5);
265        }265//         }
266        assert_eq!(TemplateModule::balance_count(1, 1), 3000);266//         assert_eq!(TemplateModule::balance_count(1, 1), 3000);
267        assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);267//         assert_eq!(TemplateModule::address_tokens(1, 1), [1, 2, 3]);
268    });268//     });
269}269// }
270270
271#[test]271#[test]
272fn transfer_fungible_item() {272fn transfer_fungible_item() {
281        let data = default_fungible_data();281        let data = default_fungible_data();
282        create_test_item(collection_id, &data.into());282        create_test_item(collection_id, &data.into());
283283
284        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 1);284        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 5);
285        assert_eq!(TemplateModule::balance_count(1, 1), 1000);285        assert_eq!(TemplateModule::balance_count(1, 1), 5);
286        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
287286
288        // change owner scenario287        // change owner scenario
289        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 1000));288        assert_ok!(TemplateModule::transfer(origin1.clone(), 2, 1, 1, 5));
290        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
291        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 1000);289        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 0);
292        assert_eq!(TemplateModule::balance_count(1, 1), 0);290        assert_eq!(TemplateModule::balance_count(1, 1), 0);
293        assert_eq!(TemplateModule::balance_count(1, 2), 1000);291        assert_eq!(TemplateModule::balance_count(1, 2), 5);
294        // assert_eq!(TemplateModule::address_tokens(1, 1), []);
295        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
296292
297        // split item scenario293        // split item scenario
298        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 500));294        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 3));
299        assert_eq!(TemplateModule::fungible_item_id(1, 1).owner, 2);
300        assert_eq!(TemplateModule::fungible_item_id(1, 2).owner, 3);
301        assert_eq!(TemplateModule::balance_count(1, 2), 500);295        assert_eq!(TemplateModule::balance_count(1, 2), 2);
302        assert_eq!(TemplateModule::balance_count(1, 3), 500);296        assert_eq!(TemplateModule::balance_count(1, 3), 3);
303        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
304        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
305297
306        // split item and new owner has account scenario298        // split item and new owner has account scenario
307        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 200));299        assert_ok!(TemplateModule::transfer(origin2.clone(), 3, 1, 1, 1));
308        assert_eq!(TemplateModule::fungible_item_id(1, 1).value, 300);300        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 1);
309        assert_eq!(TemplateModule::fungible_item_id(1, 2).value, 700);301        assert_eq!(TemplateModule::fungible_item_id(1, 3).value, 4);
310        assert_eq!(TemplateModule::balance_count(1, 2), 300);302        assert_eq!(TemplateModule::balance_count(1, 2), 1);
311        assert_eq!(TemplateModule::balance_count(1, 3), 700);303        assert_eq!(TemplateModule::balance_count(1, 3), 4);
312        assert_eq!(TemplateModule::address_tokens(1, 2), [1]);
313        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
314    });304    });
315}305}
316306
451            1), Error::<Test>::NoPermission);441            1), Error::<Test>::NoPermission);
452442
453        // do approve443        // do approve
454        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));444        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
455        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);445        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
456        assert_eq!(446        assert_eq!(
457            TemplateModule::approved(1, (1, 1))[0],447            TemplateModule::approved(1, (1, 1, 2)),
458            ApprovePermissions {448            5
459                approved: 2,
460                amount: 100000000
461            }
462        );449        );
463450
464        assert_ok!(TemplateModule::transfer_from(451        assert_ok!(TemplateModule::transfer_from(
469            1,456            1,
470            1457            1
471        ));458        ));
472        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);459        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 4);
473    });460    });
474}461}
475462
505        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));492        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
506493
507        // do approve494        // do approve
508        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));495        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
509        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);496        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
510        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));497        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));
511        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);498        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);
512        assert_eq!(
513            TemplateModule::approved(1, (1, 1))[0],
514            ApprovePermissions {
515                approved: 2,
516                amount: 100000000
517            }
518        );
519499
520        assert_ok!(TemplateModule::transfer_from(500        assert_ok!(TemplateModule::transfer_from(
521            origin2.clone(),501            origin2.clone(),
525            1,505            1,
526            1506            1
527        ));507        ));
528        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);508        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 4);
529    });509    });
530}510}
531511
560        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));540        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
561541
562        // do approve542        // do approve
563        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));543        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
564        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);544        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
565        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));545        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 1000));
566        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);546        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1000);
567        assert_eq!(
568            TemplateModule::approved(1, (1, 1))[0],
569            ApprovePermissions {
570                approved: 2,
571                amount: 100000000
572            }
573        );
574547
575        assert_ok!(TemplateModule::transfer_from(548        assert_ok!(TemplateModule::transfer_from(
576            origin2.clone(),549            origin2.clone(),
585        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);558        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
586        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);559        assert_eq!(TemplateModule::address_tokens(1, 3), [1]);
587560
588        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);561        assert_eq!(
589        assert_eq!(562            TemplateModule::approved(1, (1, 1, 3)),
590            TemplateModule::approved(1, (1, 1))[0],563            900
591            ApprovePermissions {564        );
592                approved: 3,
593                amount: 100000000
594            }
595        );
596    });565    });
597}566}
598567
609        let origin1 = Origin::signed(1);578        let origin1 = Origin::signed(1);
610        let origin2 = Origin::signed(2);579        let origin2 = Origin::signed(2);
611580
612        assert_eq!(TemplateModule::balance_count(1, 1), 1000);581        assert_eq!(TemplateModule::balance_count(1, 1), 5);
613        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
614582
615        assert_ok!(TemplateModule::set_mint_permission(583        assert_ok!(TemplateModule::set_mint_permission(
616            origin1.clone(),584            origin1.clone(),
627        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));595        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 3));
628596
629        // do approve597        // do approve
630        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));598        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
631        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);599        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
632        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1));600        assert_ok!(TemplateModule::approve(origin1.clone(), 3, 1, 1, 5));
633        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 2);601        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 5);
634        assert_eq!(602        assert_eq!(
635            TemplateModule::approved(1, (1, 1))[0],603            TemplateModule::approved(1, (1, 1, 2)),
636            ApprovePermissions {604            5
637                approved: 2,
638                amount: 100000000
639            }
640        );605        );
641606
642        assert_ok!(TemplateModule::transfer_from(607        assert_ok!(TemplateModule::transfer_from(
645            3,610            3,
646            1,611            1,
647            1,612            1,
648            100613            4
649        ));614        ));
650        assert_eq!(TemplateModule::balance_count(1, 1), 900);615        assert_eq!(TemplateModule::balance_count(1, 1), 1);
651        assert_eq!(TemplateModule::balance_count(1, 3), 100);616        assert_eq!(TemplateModule::balance_count(1, 3), 4);
652        assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
653        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
654617
655        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);618        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 5);
656        assert_eq!(619        assert_eq!(TemplateModule::approved(1, (1, 1, 3)), 1);
657            TemplateModule::approved(1, (1, 1))[0],
658            ApprovePermissions {
659                approved: 3,
660                amount: 100000000
661            }
662        );
663620
664        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));621        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 5));
665        assert_ok!(TemplateModule::transfer_from(622        assert_noop!(TemplateModule::transfer_from(
666            origin2.clone(),623            origin2.clone(),
667            1,624            1,
668            3,625            3,
669            1,626            1,
670            1,627            1,
671            900628            4
672        ));629        ), Error::<Test>::TokenValueNotEnough);
673        assert_eq!(TemplateModule::balance_count(1, 1), 0);
674        assert_eq!(TemplateModule::balance_count(1, 3), 1000);
675        // assert_eq!(TemplateModule::address_tokens(1, 1), []);
676        assert_eq!(TemplateModule::address_tokens(1, 3), [2]);
677
678        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 0);
679    });630    });
680}631}
681632
725        assert_eq!(TemplateModule::balance_count(1, 1), 1);676        assert_eq!(TemplateModule::balance_count(1, 1), 1);
726677
727        // burn item678        // burn item
728        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));679        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));
729        assert_noop!(680        assert_noop!(
730            TemplateModule::burn_item(origin1.clone(), 1, 1),681            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
731            Error::<Test>::TokenNotFound682            Error::<Test>::TokenNotFound
732        );683        );
733684
749        create_test_item(collection_id, &data.into());700        create_test_item(collection_id, &data.into());
750701
751        // check balance (collection with id = 1, user id = 1)702        // check balance (collection with id = 1, user id = 1)
752        assert_eq!(TemplateModule::balance_count(1, 1), 1000);703        assert_eq!(TemplateModule::balance_count(1, 1), 5);
753704
754        // burn item705        // burn item
755        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));706        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 5));
756        assert_noop!(707        assert_noop!(
757            TemplateModule::burn_item(origin1.clone(), 1, 1),708            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
758            Error::<Test>::TokenNotFound709            Error::<Test>::TokenNotFound
759        );710        );
760711
791        assert_eq!(TemplateModule::balance_count(1, 1), 1000);742        assert_eq!(TemplateModule::balance_count(1, 1), 1000);
792743
793        // burn item744        // burn item
794        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1));745        assert_ok!(TemplateModule::burn_item(origin1.clone(), 1, 1, 1000));
795        assert_noop!(746        assert_noop!(
796            TemplateModule::burn_item(origin1.clone(), 1, 1),747            TemplateModule::burn_item(origin1.clone(), 1, 1, 1000),
797            Error::<Test>::TokenNotFound748            Error::<Test>::TokenNotFound
798        );749        );
799750
875826
876        // check balance (collection with id = 1, user id = 1)827        // check balance (collection with id = 1, user id = 1)
877        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);828        assert_eq!(TemplateModule::balance_count(nft_collection_id, 1), 1);
878        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 1000);829        assert_eq!(TemplateModule::balance_count(fungible_collection_id, 1), 5);
879        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);830        assert_eq!(TemplateModule::balance_count(re_fungible_collection_id, 1), 1000);
880        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);831        assert_eq!(TemplateModule::nft_item_id(nft_collection_id, 1).owner, 1);
881        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).owner, 1);832        assert_eq!(TemplateModule::fungible_item_id(fungible_collection_id, 1).value, 5);
882        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);833        assert_eq!(TemplateModule::refungible_item_id(re_fungible_collection_id, 1).owner[0].owner, 1);
883    });834    });
884}835}
896        let origin1 = Origin::signed(1);847        let origin1 = Origin::signed(1);
897        848        
898        // approve849        // approve
899        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));850        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));
900        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);851        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);
901    });852    });
902}853}
903854
914        create_test_item(collection_id, &data.into());865        create_test_item(collection_id, &data.into());
915866
916        // approve867        // approve
917        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1));868        assert_ok!(TemplateModule::approve(origin1.clone(), 2, 1, 1, 1));
918        assert_eq!(TemplateModule::approved(1, (1, 1))[0].approved, 2);869        assert_eq!(TemplateModule::approved(1, (1, 1, 2)), 1);
919870
920        assert_ok!(TemplateModule::set_mint_permission(871        assert_ok!(TemplateModule::set_mint_permission(
921            origin1.clone(),872            origin1.clone(),
1199        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));1150        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), 1, 2));
12001151
1201        // do approve1152        // do approve
1202        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1153        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));
1203        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1154        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
12041155
1205        assert_ok!(TemplateModule::remove_from_white_list(1156        assert_ok!(TemplateModule::remove_from_white_list(
1206            origin1.clone(),1157            origin1.clone(),
1263        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1214        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
12641215
1265        // do approve1216        // do approve
1266        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1217        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 1));
1267        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1218        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 1);
12681219
1269        assert_ok!(TemplateModule::remove_from_white_list(1220        assert_ok!(TemplateModule::remove_from_white_list(
1270            origin1.clone(),1221            origin1.clone(),
1298            AccessMode::WhiteList1249            AccessMode::WhiteList
1299        ));1250        ));
1300        assert_noop!(1251        assert_noop!(
1301            TemplateModule::burn_item(origin1.clone(), 1, 1),1252            TemplateModule::burn_item(origin1.clone(), 1, 1, 5),
1302            Error::<Test>::AddresNotInWhiteList1253            Error::<Test>::AddresNotInWhiteList
1303        );1254        );
1304    });1255    });
13211272
1322        // do approve1273        // do approve
1323        assert_noop!(1274        assert_noop!(
1324            TemplateModule::approve(origin1.clone(), 1, 1, 1),1275            TemplateModule::approve(origin1.clone(), 1, 1, 1, 5),
1325            Error::<Test>::AddresNotInWhiteList1276            Error::<Test>::AddresNotInWhiteList
1326        );1277        );
1327    });1278    });
1374        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));1325        assert_ok!(TemplateModule::add_to_white_list(origin1.clone(), collection_id, 2));
13751326
1376        // do approve1327        // do approve
1377        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1));1328        assert_ok!(TemplateModule::approve(origin1.clone(), 1, 1, 1, 5));
1378        assert_eq!(TemplateModule::approved(1, (1, 1)).len(), 1);1329        assert_eq!(TemplateModule::approved(1, (1, 1, 1)), 5);
13791330
1380        assert_ok!(TemplateModule::transfer_from(1331        assert_ok!(TemplateModule::transfer_from(
1381            origin1.clone(),1332            origin1.clone(),
modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -20,9 +20,13 @@
     "load": "mocha --timeout 9999999 -r ts-node/register ./**/*.load.ts",
     "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
     "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
+    "testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",
     "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
     "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
-    "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts"
+    "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts",
+    "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",
+    "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",
+    "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts"
   },
   "author": "",
   "license": "Apache 2.0",
addedtests/src/approve.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/approve.test.ts
@@ -0,0 +1,140 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+import { ApiPromise } from '@polkadot/api';
+import BN from 'bn.js';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import privateKey from './substrate/privateKey';
+import { default as usingApi } from './substrate/substrate-api';
+import {
+  approveExpectFail,
+  approveExpectSuccess,
+  createCollectionExpectSuccess,
+  createItemExpectSuccess,
+  destroyCollectionExpectSuccess,
+} from './util/helpers';
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe('Integration Test approve(spender, collection_id, item_id, amount):', () => {
+  it('Execute the extrinsic and check approvedList', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
+    });
+  });
+
+  it('Remove approval by using 0 amount', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1);
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 0);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1);
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 0);
+      // reFungible
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 1);
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 0);
+    });
+  });
+});
+
+describe('Negative Integration Test approve(spender, collection_id, item_id, amount):', () => {
+  it('Approve for a collection that does not exist', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await approveExpectFail(nftCollectionCount + 1, 1, Alice, Bob);
+      // fungible
+      const fungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await approveExpectFail(fungibleCollectionCount + 1, 1, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await approveExpectFail(reFungibleCollectionCount + 1, 1, Alice, Bob);
+    });
+  });
+
+  it('Approve for a collection that was destroyed', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await approveExpectFail(nftCollectionId, 1, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await approveExpectFail(fungibleCollectionId, 1, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
+      await approveExpectFail(reFungibleCollectionId, 1, Alice, Bob);
+    });
+  });
+
+  it('Approve transfer of a token that does not exist', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await approveExpectFail(nftCollectionId, 2, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      await approveExpectFail(fungibleCollectionId, 2, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      await approveExpectFail(reFungibleCollectionId, 2, Alice, Bob);
+    });
+  });
+
+  it('Approve using the address that does not own the approved token', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectFail(nftCollectionId, newNftTokenId, Bob, Alice);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice);
+      // reFungible
+      const reFungibleCollectionId =
+        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice);
+    });
+  });
+});
addedtests/src/burnItem.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/burnItem.test.ts
@@ -0,0 +1,237 @@
+import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
+import { Keyring } from "@polkadot/api";
+import { IKeyringPair } from "@polkadot/types/types";
+import { 
+  createCollectionExpectSuccess, 
+  createItemExpectSuccess,
+  getGenericResult,
+  destroyCollectionExpectSuccess
+} from './util/helpers';
+import { nullPublicKey } from "./accounts";
+
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+let alice: IKeyringPair;
+let bob: IKeyringPair;
+
+describe('integration test: ext. burnItem():', () => {
+  before(async () => {
+    await usingApi(async (api) => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      alice = keyring.addFromUri(`//Alice`);
+      bob = keyring.addFromUri(`//Bob`);
+    });
+  });
+
+  it('Burn item in NFT collection', async () => {
+    const createMode = 'NFT';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
+    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+
+    await usingApi(async (api) => {
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+      const events = await submitTransactionAsync(alice, tx);
+      const result = getGenericResult(events);
+  
+      // Get the item 
+      const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();
+ 
+      // What to expect
+      expect(result.success).to.be.true;
+      expect(item).to.be.not.null;
+      expect(item.Owner).to.be.equal(nullPublicKey);
+    });
+  
+  });
+  it('Burn item in Fungible collection', async () => {
+    const createMode = 'Fungible';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0 }});
+    await createItemExpectSuccess(alice, collectionId, createMode); // Helper creates 10 fungible tokens
+    const tokenId = 0; // ignored
+
+    await usingApi(async (api) => {
+      // Destroy 1 of 10
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
+      const events = await submitTransactionAsync(alice, tx);
+      const result = getGenericResult(events);
+  
+      // Get alice balance 
+      const balance: any = (await api.query.nft.fungibleItemList(collectionId, alice.address)).toJSON();
+ 
+      // What to expect
+      expect(result.success).to.be.true;
+      expect(balance).to.be.not.null;
+      expect(balance.Value).to.be.equal(9);
+    });
+
+  });
+  it('Burn item in ReFungible collection', async () => {
+    const createMode = 'ReFungible';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 2 }});
+    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+
+    await usingApi(async (api) => {
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 1);
+      const events = await submitTransactionAsync(alice, tx);
+      const result = getGenericResult(events);
+  
+      // Get alice balance 
+      const balance: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
+      
+      // What to expect
+      expect(result.success).to.be.true;
+      expect(balance).to.be.not.null;
+      expect(balance.Owner.length).to.be.equal(0);
+    });
+
+  });
+
+  it('Burn owned portion of item in ReFungible collection', async () => {
+    const createMode = 'ReFungible';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 2 }});
+    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+
+    await usingApi(async (api) => {
+      // Transfer 1/100 of the token to Bob
+      const transfertx = api.tx.nft.transfer(bob.address, collectionId, tokenId, 1);
+      const events1 = await submitTransactionAsync(alice, transfertx);
+      const result1 = getGenericResult(events1);
+
+      // Get balances
+      const balanceBefore: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
+
+      // Bob burns his portion
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+      const events2 = await submitTransactionAsync(bob, tx);
+      const result2 = getGenericResult(events2);
+  
+      // Get balances 
+      const balance: any = (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON();
+      // console.log(balance);
+      
+      // What to expect before burning
+      expect(result1.success).to.be.true;
+      expect(balanceBefore).to.be.not.null;
+      expect(balanceBefore.Owner.length).to.be.equal(2);
+      expect(balanceBefore.Owner[0].Owner).to.be.equal(alice.address);
+      expect(balanceBefore.Owner[0].Fraction).to.be.equal(99);
+      expect(balanceBefore.Owner[1].Owner).to.be.equal(bob.address);
+      expect(balanceBefore.Owner[1].Fraction).to.be.equal(1);
+
+      // What to expect after burning
+      expect(result2.success).to.be.true;
+      expect(balance).to.be.not.null;
+      expect(balance.Owner.length).to.be.equal(1);
+      expect(balance.Owner[0].Fraction).to.be.equal(99);
+      expect(balance.Owner[0].Owner).to.be.equal(alice.address);
+    });
+
+  });
+
+});
+
+describe('Negative integration test: ext. burnItem():', () => {
+  before(async () => {
+    await usingApi(async (api) => {
+      const keyring = new Keyring({ type: 'sr25519' });
+      alice = keyring.addFromUri(`//Alice`);
+      bob = keyring.addFromUri(`//Bob`);
+    });
+  });
+
+  it('Burn a token in a destroyed collection', async () => {
+    const createMode = 'NFT';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode }});
+    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+    await destroyCollectionExpectSuccess(collectionId);
+
+    await usingApi(async (api) => {
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+      const badTransaction = async function () { 
+        await submitTransactionExpectFailAsync(alice, tx);
+      };
+      await expect(badTransaction()).to.be.rejected;
+    });
+
+  });
+
+  it('Burn a token that was never created', async () => {
+    const createMode = 'NFT';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode }});
+    const tokenId = 10;
+
+    await usingApi(async (api) => {
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+      const badTransaction = async function () { 
+        await submitTransactionExpectFailAsync(alice, tx);
+      };
+      await expect(badTransaction()).to.be.rejected;
+    });
+
+  });
+
+  it('Burn a token using the address that does not own it', async () => {
+    const createMode = 'NFT';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode }});
+    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+
+    await usingApi(async (api) => {
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+      const badTransaction = async function () { 
+        await submitTransactionExpectFailAsync(bob, tx);
+      };
+      await expect(badTransaction()).to.be.rejected;
+    });
+
+  });
+
+  it('Transfer a burned a token', async () => {
+    const createMode = 'NFT';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode }});
+    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
+
+    await usingApi(async (api) => {
+
+      const burntx = api.tx.nft.burnItem(collectionId, tokenId, 0);
+      const events1 = await submitTransactionAsync(alice, burntx);
+      const result1 = getGenericResult(events1);
+      expect(result1.success).to.be.true;
+  
+      const tx = api.tx.nft.transfer(bob.address, collectionId, tokenId, 0);
+      const badTransaction = async function () { 
+        await submitTransactionExpectFailAsync(alice, tx);
+      };
+      await expect(badTransaction()).to.be.rejected;
+    });
+
+  });
+
+  it('Burn more than owned in Fungible collection', async () => {
+    const createMode = 'Fungible';
+    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0 }});
+    // Helper creates 10 fungible tokens
+    await createItemExpectSuccess(alice, collectionId, createMode);
+    const tokenId = 0; // ignored
+
+    await usingApi(async (api) => {
+      // Destroy 11 of 10
+      const tx = api.tx.nft.burnItem(collectionId, tokenId, 11);
+      const badTransaction = async function () { 
+        await submitTransactionExpectFailAsync(alice, tx);
+      };
+      await expect(badTransaction()).to.be.rejected;
+      
+      // Get alice balance 
+      const balance: any = (await api.query.nft.fungibleItemList(collectionId, alice.address)).toJSON();
+ 
+      // What to expect
+      expect(balance).to.be.not.null;
+      expect(balance.Value).to.be.equal(10);
+    });
+
+  });
+
+});
modifiedtests/src/confirmSponsorship.test.tsdiffbeforeafterboth
--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -89,7 +89,7 @@
   });
 
   it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0 }});
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
 
@@ -115,7 +115,7 @@
   });
 
   it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0 }});
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
 
@@ -210,7 +210,7 @@
   });
 
   it('Fungible: Sponsoring is rate limited', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0 }});
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
 
@@ -247,7 +247,7 @@
   });
 
   it('ReFungible: Sponsoring is rate limited', async () => {
-    const collectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0 }});
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
     await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
modifiedtests/src/createCollection.test.tsdiffbeforeafterboth
--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -5,15 +5,15 @@
 
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import { default as usingApi } from "./substrate/substrate-api";
-import { createCollectionExpectSuccess, createCollectionExpectFailure, CollectionMode } from "./util/helpers";
+import { default as usingApi } from './substrate/substrate-api';
+import { createCollectionExpectFailure, createCollectionExpectSuccess } from './util/helpers';
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
 describe('integration test: ext. createCollection():', () => {
   it('Create new NFT collection', async () => {
-    await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});
+    await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
   });
   it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {
     await createCollectionExpectSuccess({name: 'A'.repeat(64)});
@@ -25,34 +25,35 @@
     await createCollectionExpectSuccess({tokenPrefix: 'A'.repeat(16)});
   });
   it('Create new Fungible collection', async () => {
-    await createCollectionExpectSuccess({mode: 'Fungible'});
+    await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
   });
   it('Create new ReFungible collection', async () => {
-    await createCollectionExpectSuccess({mode: 'ReFungible'});
+    await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
   });
 });
 
 describe('(!negative test!) integration test: ext. createCollection():', () => {
   it('(!negative test!) create new NFT collection whith incorrect data (mode)', async () => {
     await usingApi(async (api) => {
-      const AcollectionCount = parseInt((await api.query.nft.collectionCount()).toString());
+      const AcollectionCount = parseInt((await api.query.nft.collectionCount()).toString(), 10);
 
-      const badTransaction = async function () { 
-        await createCollectionExpectSuccess({mode: 'BadMode' as CollectionMode});
+      const badTransaction = async () => {
+        await createCollectionExpectSuccess({mode: {type: 'Invalid'}});
       };
+      // tslint:disable-next-line:no-unused-expression
       expect(badTransaction()).to.be.rejected;
 
-      const BcollectionCount = parseInt((await api.query.nft.collectionCount()).toString());
+      const BcollectionCount = parseInt((await api.query.nft.collectionCount()).toString(), 10);
       expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Incorrect collection created.');
     });
   });
   it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {
-    await createCollectionExpectFailure({name: 'A'.repeat(65)});
+    await createCollectionExpectFailure({ name: 'A'.repeat(65), mode: {type: 'NFT'}});
   });
   it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {
-    await createCollectionExpectFailure({description: 'A'.repeat(257)});
+    await createCollectionExpectFailure({ description: 'A'.repeat(257), mode: { type: 'NFT' }});
   });
   it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {
-    await createCollectionExpectFailure({tokenPrefix: 'A'.repeat(17)});
+    await createCollectionExpectFailure({tokenPrefix: 'A'.repeat(17), mode: {type: 'NFT'}});
   });
 });
modifiedtests/src/createItem.test.tsdiffbeforeafterboth
--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -18,17 +18,17 @@
 
   it('Create new item in NFT collection', async () => {
     const createMode = 'NFT';
-    const newCollectionID = await createCollectionExpectSuccess({mode: createMode});
+    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
     await createItemExpectSuccess(alice, newCollectionID, createMode);
   });
   it('Create new item in Fungible collection', async () => {
     const createMode = 'Fungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: createMode});
+    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
     await createItemExpectSuccess(alice, newCollectionID, createMode);
   });
   it('Create new item in ReFungible collection', async () => {
     const createMode = 'ReFungible';
-    const newCollectionID = await createCollectionExpectSuccess({mode: createMode});
+    const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
     await createItemExpectSuccess(alice, newCollectionID, createMode);
   });
 });
modifiedtests/src/destroyCollection.test.tsdiffbeforeafterboth
--- a/tests/src/destroyCollection.test.ts
+++ b/tests/src/destroyCollection.test.ts
@@ -14,11 +14,11 @@
     await destroyCollectionExpectSuccess(collectionId);
   });
   it('Fungible collection can be destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess({ mode: 'Fungible' });
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
     await destroyCollectionExpectSuccess(collectionId);
   });
   it('ReFungible collection can be destroyed', async () => {
-    const collectionId = await createCollectionExpectSuccess({ mode: 'ReFungible' });
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
     await destroyCollectionExpectSuccess(collectionId);
   });
 });
addedtests/src/removeCollectionAdmin.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/removeCollectionAdmin.test.ts
@@ -0,0 +1,82 @@
+import { ApiPromise } from '@polkadot/api';
+import BN from 'bn.js';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import privateKey from './substrate/privateKey';
+import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
+import {createCollectionExpectSuccess, destroyCollectionExpectSuccess} from './util/helpers';
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe('Integration Test removeCollectionAdmin(collection_id, account_id):', () => {
+  it('Remove collection admin.', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const collectionId = await createCollectionExpectSuccess();
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const collection: any = (await api.query.nft.collection(collectionId));
+      expect(collection.Owner.toString()).to.be.eq(Alice.address);
+      // first - add collection admin Bob
+      const addAdminTx = api.tx.nft.addCollectionAdmin(collectionId, Bob.address);
+      await submitTransactionAsync(Alice, addAdminTx);
+
+      const adminListAfterAddAdmin: any = (await api.query.nft.adminList(collectionId));
+      expect(adminListAfterAddAdmin).to.be.contains(Bob.address);
+
+      // then remove bob from admins of collection
+      const removeAdminTx = api.tx.nft.removeCollectionAdmin(collectionId, Bob.address);
+      await submitTransactionAsync(Alice, removeAdminTx);
+
+      const adminListAfterRemoveAdmin: any = (await api.query.nft.adminList(collectionId));
+      expect(adminListAfterRemoveAdmin).not.to.be.contains(Bob.address);
+    });
+  });
+});
+
+describe('Negative Integration Test removeCollectionAdmin(collection_id, account_id):', () => {
+  it('Can\'t remove collection admin from not existing collection', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      // tslint:disable-next-line: no-bitwise
+      const collectionId = (1 << 32) - 1;
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+
+      const changeOwnerTx = api.tx.nft.removeCollectionAdmin(collectionId, bob.address);
+      await expect(submitTransactionExpectFailAsync(alice, changeOwnerTx)).to.be.rejected;
+
+      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
+      await createCollectionExpectSuccess();
+    });
+  });
+
+  it('Can\'t remove collection admin from deleted collection', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      // tslint:disable-next-line: no-bitwise
+      const collectionId = await createCollectionExpectSuccess();
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+
+      await destroyCollectionExpectSuccess(collectionId);
+
+      const changeOwnerTx = api.tx.nft.removeCollectionAdmin(collectionId, Bob.address);
+      await expect(submitTransactionExpectFailAsync(Alice, changeOwnerTx)).to.be.rejected;
+
+      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
+      await createCollectionExpectSuccess();
+    });
+  });
+
+  it('Remove admin from collection that has no admins', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const collectionId = await createCollectionExpectSuccess();
+
+      const adminListBeforeAddAdmin: any = (await api.query.nft.adminList(collectionId));
+      expect(adminListBeforeAddAdmin).to.have.lengthOf(0);
+
+      const tx = api.tx.nft.removeCollectionAdmin(collectionId, Alice.address);
+      await expect(submitTransactionExpectFailAsync(Alice, tx)).to.be.rejected;
+    });
+  });
+});
modifiedtests/src/setCollectionLimits.test.tsdiffbeforeafterboth
--- a/tests/src/setCollectionLimits.test.ts
+++ b/tests/src/setCollectionLimits.test.ts
@@ -32,7 +32,7 @@
   });
   it('choose or create collection for testing', async () => {
     await usingApi(async () => {
-      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});
+      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
     });
   });
 });
modifiedtests/src/setCollectionSponsor.test.tsdiffbeforeafterboth
--- a/tests/src/setCollectionSponsor.test.ts
+++ b/tests/src/setCollectionSponsor.test.ts
@@ -30,11 +30,11 @@
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
   });
   it('Set Fungible collection sponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess({ mode: 'Fungible' });
+    const collectionId = await createCollectionExpectSuccess({ mode: {type: 'Fungible', decimalPoints: 0} });
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
   });
   it('Set ReFungible collection sponsor', async () => {
-    const collectionId = await createCollectionExpectSuccess({ mode: 'ReFungible' });
+    const collectionId = await createCollectionExpectSuccess({ mode: {type: 'ReFungible', decimalPoints: 0} });
     await setCollectionSponsorExpectSuccess(collectionId, bob.address);
   });
modifiedtests/src/setSchemaVersion.test.tsdiffbeforeafterboth
--- a/tests/src/setSchemaVersion.test.ts
+++ b/tests/src/setSchemaVersion.test.ts
@@ -35,7 +35,7 @@
   });
   it('choose or create collection for testing', async () => {
     await usingApi(async () => {
-      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});
+      collectionIdForTesting = await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
     });
   });
 });
@@ -93,12 +93,6 @@
       const nonExistedCollectionId = collectionCount + 1;
       tx = api.tx.nft.setSchemaVersion(nonExistedCollectionId, 'ImageURL');
       await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
-      /*try {
-        await submitTransactionAsync(alice, tx);
-      } catch (e) {
-        // tslint:disable-next-line:no-unused-expression
-        expect(e).to.be.exist;
-      }*/
     });
   });
 
@@ -119,13 +113,6 @@
       await destroyCollectionExpectSuccess(collectionIdForTesting);
       tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');
       await expect(submitTransactionExpectFailAsync(alice, tx)).to.be.rejected;
-      /*try {
-        tx = api.tx.nft.setSchemaVersion(collectionIdForTesting, 'ImageURL');
-        await submitTransactionAsync(alice, tx);
-      } catch (e) {
-        // tslint:disable-next-line:no-unused-expression
-        expect(e).to.be.exist;
-      }*/
     });
   });
 });
modifiedtests/src/substrate/substrate-api.tsdiffbeforeafterboth
--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -90,7 +90,6 @@
         res(rec);
         console.error = consoleError;
         console.log = consoleLog;
-        
       });
     };
     const reject = (errror: any) => {
@@ -104,6 +103,8 @@
       await transaction.signAndSend(sender, ({ events = [], status }) => {
         const transactionStatus = getTransactionStatus(events, status);
 
+        console.log('transactionStatus', transactionStatus, 'events', events);
+
         if (transactionStatus == TransactionStatus.Success) {
           resolve(events);
         } else if (transactionStatus == TransactionStatus.Fail) {
@@ -114,4 +115,4 @@
       reject(e);
     }
   });
-}
\ No newline at end of file
+}
addedtests/src/transferFrom.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/transferFrom.test.ts
@@ -0,0 +1,188 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+import { ApiPromise } from '@polkadot/api';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import privateKey from './substrate/privateKey';
+import { default as usingApi } from './substrate/substrate-api';
+import {
+  approveExpectFail,
+  approveExpectSuccess,
+  createCollectionExpectSuccess,
+  createItemExpectSuccess,
+  destroyCollectionExpectSuccess,
+  transferFromExpectFail,
+  transferFromExpectSuccess,
+} from './util/helpers';
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe('Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {
+  it('Execute the extrinsic and check nftItemList - owner of token', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
+
+      await transferFromExpectSuccess(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1, 'NFT');
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      await transferFromExpectSuccess(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1, 'Fungible');
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
+      await transferFromExpectSuccess(reFungibleCollectionId,
+        newReFungibleTokenId, Bob, Alice, Charlie, 1, 'ReFungible');
+    });
+  });
+});
+
+describe('Negative Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {
+  it('transferFrom for a collection that does not exist', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await approveExpectFail(nftCollectionCount + 1, 1, Alice, Bob);
+
+      await transferFromExpectFail(nftCollectionCount + 1, 1, Bob, Alice, Charlie, 1);
+
+      // fungible
+      const fungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await approveExpectFail(fungibleCollectionCount + 1, 1, Alice, Bob);
+
+      await transferFromExpectFail(fungibleCollectionCount + 1, 1, Bob, Alice, Charlie, 1);
+      // reFungible
+      const reFungibleCollectionCount = await api.query.nft.createdCollectionCount() as unknown as number;
+      await approveExpectFail(reFungibleCollectionCount + 1, 1, Alice, Bob);
+
+      await transferFromExpectFail(reFungibleCollectionCount + 1, 1, Bob, Alice, Charlie, 1);
+    });
+  });
+
+  /* it('transferFrom for a collection that was destroyed', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      this test copies approve negative test
+    });
+  }); */
+
+  /* it('transferFrom a token that does not exist', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      this test copies approve negative test
+    });
+  }); */
+
+  /* it('transferFrom a token that was deleted', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      this test copies approve negative test
+    });
+  }); */
+
+  it('transferFrom for not approved address', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+
+      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await transferFromExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Bob, Alice, Charlie, 1);
+    });
+  });
+
+  it('transferFrom incorrect token count', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
+
+      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 2);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 2);
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
+      await transferFromExpectFail(reFungibleCollectionId,
+        newReFungibleTokenId, Bob, Alice, Charlie, 2);
+    });
+  });
+
+  it('execute transferFrom from account that is not owner of collection', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      const Dave = privateKey('//DAVE');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      try {
+        await approveExpectFail(nftCollectionId, newNftTokenId, Dave, Bob);
+        await transferFromExpectFail(nftCollectionId, newNftTokenId, Dave, Alice, Charlie, 1);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+
+      // await transferFromExpectFail(nftCollectionId, newNftTokenId, Dave, Alice, Charlie, 1);
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      try {
+        await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Dave, Bob);
+        await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Dave, Alice, Charlie, 1);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+      // reFungible
+      const reFungibleCollectionId = await
+        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      try {
+        await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Dave, Bob);
+        await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Dave, Alice, Charlie, 1);
+      } catch (e) {
+        // tslint:disable-next-line:no-unused-expression
+        expect(e).to.be.exist;
+      }
+    });
+  });
+});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -3,20 +3,20 @@
 // file 'LICENSE', which is part of this source code package.
 //
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import { ApiPromise, Keyring } from '@polkadot/api';
+import { Enum, Struct } from '@polkadot/types/codec';
 import type { AccountId, EventRecord } from '@polkadot/types/interfaces';
-import { ApiPromise, Keyring } from "@polkadot/api";
-import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from "../substrate/substrate-api";
-import privateKey from '../substrate/privateKey';
-import { alicesPublicKey, nullPublicKey } from "../accounts";
-import { strToUTF16, utf16ToStr, hexToStr } from './util';
+import { u128 } from '@polkadot/types/primitive';
 import { IKeyringPair } from '@polkadot/types/types';
 import { BigNumber } from 'bignumber.js';
-import { Struct, Enum } from '@polkadot/types/codec';
-import { u128 } from '@polkadot/types/primitive';
+import BN from 'bn.js';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import { alicesPublicKey, nullPublicKey } from '../accounts';
+import privateKey from '../substrate/privateKey';
+import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';
 import { ICollectionInterface } from '../types';
-import BN from "bn.js";
+import { hexToStr, strToUTF16, utf16ToStr } from './util';
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
@@ -25,24 +25,45 @@
   success: boolean,
 };
 
-type CreateCollectionResult = {
-  success: boolean,
-  collectionId: number
-};
+interface CreateCollectionResult {
+  success: boolean;
+  collectionId: number;
+}
+
+interface CreateItemResult {
+  success: boolean;
+  collectionId: number;
+  itemId: number;
+}
+
+interface IReFungibleOwner {
+  Fraction: BN;
+  Owner: number[];
+}
+
+interface ITokenDataType {
+  Owner: number[];
+  ConstData: number[];
+  VariableData: number[];
+}
+
+interface IFungibleTokenDataType {
+  Value: BN;
+}
 
-type CreateItemResult = {
-  success: boolean,
-  collectionId: number,
-  itemId: number
-};
+interface IReFungibleTokenDataType {
+  Owner: IReFungibleOwner[];
+  ConstData: number[];
+  VariableData: number[];
+}
 
 export function getGenericResult(events: EventRecord[]): GenericResult {
-  let result: GenericResult = {
-    success: false
-  }
+  const result: GenericResult = {
+    success: false,
+  };
   events.forEach(({ phase, event: { data, method, section } }) => {
     // console.log(`    ${phase}: ${section}.${method}:: ${data}`);
-    if (method == 'ExtrinsicSuccess') {
+    if (method === 'ExtrinsicSuccess') {
       result.success = true;
     }
   });
@@ -60,10 +81,10 @@
       collectionId = parseInt(data[0].toString());
     }
   });
-  let result: CreateCollectionResult = {
+  const result: CreateCollectionResult = {
     success,
-    collectionId
-  }
+    collectionId,
+  };
   return result;
 }
 
@@ -80,27 +101,60 @@
       itemId = parseInt(data[1].toString());
     }
   });
-  let result: CreateItemResult = {
+  const result: CreateItemResult = {
     success,
     collectionId,
-    itemId
-  }
+    itemId,
+  };
   return result;
 }
 
-export type CollectionMode = 'NFT' | 'Fungible' | 'ReFungible';
+interface Invalid {
+  type: 'Invalid';
+}
+
+interface Nft {
+  type: 'NFT';
+}
+
+interface Fungible {
+  type: 'Fungible';
+  decimalPoints: number;
+}
+
+interface ReFungible {
+  type: 'ReFungible';
+  decimalPoints: number;
+}
+
+interface Nft {
+  type: 'NFT'
+}
+
+interface Fungible {
+  type: 'Fungible',
+  decimalPoints: number
+}
+
+interface ReFungible {
+  type: 'ReFungible',
+  decimalPoints: number
+}
+
+type CollectionMode = Nft | Fungible | ReFungible | Invalid;
+
 export type CreateCollectionParams = {
   mode: CollectionMode,
   name: string,
   description: string,
-  tokenPrefix: string
+  tokenPrefix: string,
 };
 
 const defaultCreateCollectionParams: CreateCollectionParams = {
+  description: 'description',
+  mode: { type: 'NFT' },
   name: 'name',
-  description: 'description',
-  mode: 'NFT',
-  tokenPrefix: 'prefix'
+  tokenPrefix: 'prefix',
 }
 
 export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {
@@ -109,25 +163,39 @@
   let collectionId: number = 0;
   await usingApi(async (api) => {
     // Get number of collections before the transaction
-    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());
+    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);
 
     // Run the CreateCollection transaction
     const alicePrivateKey = privateKey('//Alice');
-    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), mode);
+
+    let modeprm = {};
+    if (mode.type === 'NFT') {
+      modeprm = {nft: null};
+    } else if (mode.type === 'Fungible') {
+      modeprm = {fungible: mode.decimalPoints};
+    } else if (mode.type === 'ReFungible') {
+      modeprm = {refungible: mode.decimalPoints};
+    } else if (mode.type === 'Invalid') {
+      modeprm = {invalid: null};
+    }
+
+    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);
     const events = await submitTransactionAsync(alicePrivateKey, tx);
     const result = getCreateCollectionResult(events);
 
     // Get number of collections after the transaction
-    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());
+    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();
 
     // What to expect
+    // tslint:disable-next-line:no-unused-expression
     expect(result.success).to.be.true;
     expect(result.collectionId).to.be.equal(BcollectionCount);
+    // tslint:disable-next-line:no-unused-expression
     expect(collection).to.be.not.null;
-    expect(BcollectionCount).to.be.equal(AcollectionCount+1, 'Error: NFT collection NOT created.');
+    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');
     expect(collection.Owner).to.be.equal(alicesPublicKey);
     expect(utf16ToStr(collection.Name)).to.be.equal(name);
     expect(utf16ToStr(collection.Description)).to.be.equal(description);
@@ -138,17 +206,28 @@
 
   return collectionId;
 }
-  
+
 export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {
   const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};
 
+  let modeprm = {};
+  if (mode.type === 'NFT') {
+    modeprm = {nft: null};
+  } else if (mode.type === 'Fungible') {
+    modeprm = {fungible: mode.decimalPoints};
+  } else if (mode.type === 'ReFungible') {
+    modeprm = {refungible: mode.decimalPoints};
+  } else if (mode.type === 'Invalid') {
+    modeprm = {invalid: null};
+  }
+
   await usingApi(async (api) => {
     // Get number of collections before the transaction
     const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());
 
     // Run the CreateCollection transaction
     const alicePrivateKey = privateKey('//Alice');
-    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), mode);
+    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);
     const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;
     const result = getCreateCollectionResult(events);
 
@@ -156,11 +235,12 @@
     const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());
 
     // What to expect
+    // tslint:disable-next-line:no-unused-expression
     expect(result.success).to.be.false;
     expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');
   });
 }
-  
+
 export async function findUnusedAddress(api: ApiPromise): Promise<IKeyringPair> {
   let bal = new BigNumber(0);
   let unused;
@@ -170,7 +250,7 @@
     unused = keyring.addFromUri(`//${randomSeed}`);
     bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());
   } while (bal.toFixed() != '0');
-  return unused; 
+  return unused;
 }
 
 function getDestroyResult(events: EventRecord[]): boolean {
@@ -201,7 +281,7 @@
     const events = await submitTransactionAsync(alicePrivateKey, tx);
     const result = getDestroyResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect
@@ -220,7 +300,7 @@
     const events = await submitTransactionAsync(alicePrivateKey, tx);
     const result = getGenericResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect
@@ -239,7 +319,7 @@
     const events = await submitTransactionAsync(alicePrivateKey, tx);
     const result = getGenericResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect
@@ -278,7 +358,7 @@
     const events = await submitTransactionAsync(sender, tx);
     const result = getGenericResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect
@@ -300,49 +380,132 @@
 
 export interface CreateFungibleData extends Struct {
   readonly value: u128;
-};
+}
 
-export interface CreateReFungibleData extends Struct {};
-export interface CreateNftData extends Struct {};
+export interface CreateReFungibleData extends Struct {}
+export interface CreateNftData extends Struct {}
 
 export interface CreateItemData extends Enum {
-  NFT: CreateNftData,
-  Fungible: CreateFungibleData,
-  ReFungible: CreateReFungibleData
-};
+  NFT: CreateNftData;
+  Fungible: CreateFungibleData;
+  ReFungible: CreateReFungibleData;
+}
+
+export async function
+approveExpectSuccess(collectionId: number,
+                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {
+  await usingApi(async (api: ApiPromise) => {
+    const allowanceBefore =
+      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;
+    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);
+    const events = await submitTransactionAsync(owner, approveNftTx);
+    const result = getCreateItemResult(events);
+    // tslint:disable-next-line:no-unused-expression
+    expect(result.success).to.be.true;
+    const allowanceAfter =
+      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;
+    expect(allowanceAfter.toNumber() - allowanceBefore.toNumber()).to.be.equal(amount);
+  });
+}
 
+export async function
+transferFromExpectSuccess(collectionId: number,
+                          tokenId: number,
+                          accountApproved: IKeyringPair,
+                          accountFrom: IKeyringPair,
+                          accountTo: IKeyringPair,
+                          value: number = 1,
+                          type: string = 'NFT') {
+  await usingApi(async (api: ApiPromise) => {
+    let balanceBefore = new BN(0);
+    if (type === 'Fungible') {
+      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;
+    }
+    const transferFromTx = await api.tx.nft.transferFrom(
+      accountFrom.address, accountTo.address, collectionId, tokenId, value);
+    const events = await submitTransactionAsync(accountFrom, transferFromTx);
+    const result = getCreateItemResult(events);
+    // tslint:disable-next-line:no-unused-expression
+    expect(result.success).to.be.true;
+    if (type === 'NFT') {
+      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
+      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);
+    }
+    if (type === 'Fungible') {
+      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;
+      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);
+    }
+    if (type === 'ReFungible') {
+      const nftItemData =
+        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;
+      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);
+      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);
+    }
+  });
+}
+
+export async function
+transferFromExpectFail(collectionId: number,
+                       tokenId: number,
+                       accountApproved: IKeyringPair,
+                       accountFrom: IKeyringPair,
+                       accountTo: IKeyringPair,
+                       value: number = 1) {
+  await usingApi(async (api: ApiPromise) => {
+    const transferFromTx = await api.tx.nft.transferFrom(
+      accountFrom.address, accountTo.address, collectionId, tokenId, value);
+    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;
+    const result = getCreateCollectionResult(events);
+    // tslint:disable-next-line:no-unused-expression
+    expect(result.success).to.be.false;
+  });
+}
+
+export async function
+approveExpectFail(collectionId: number,
+                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {
+  await usingApi(async (api: ApiPromise) => {
+    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);
+    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;
+    const result = getCreateCollectionResult(events);
+    // tslint:disable-next-line:no-unused-expression
+    expect(result.success).to.be.false;
+  });
+}
+
 export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {
   let newItemId: number = 0;
   await usingApi(async (api) => {
-    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString());
-    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();    
+    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);
+    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();
     const AItemBalance = new BigNumber(Aitem.Value);
 
-    if (owner === '') owner = sender.address;
+    if (owner === '') {
+      owner = sender.address;
+    }
 
     let tx;
-    if (createMode == 'Fungible') {
-      let createData = {fungible: {value: 10}};
+    if (createMode === 'Fungible') {
+      const createData = {fungible: {value: 10}};
       tx = api.tx.nft.createItem(collectionId, owner, createData);
-    }
-    else {
+    } else {
       tx = api.tx.nft.createItem(collectionId, owner, createMode);
     }
     const events = await submitTransactionAsync(sender, tx);
     const result = getCreateItemResult(events);
 
-    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString());
-    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();    
+    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);
+    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();
     const BItemBalance = new BigNumber(Bitem.Value);
 
     // What to expect
+    // tslint:disable-next-line:no-unused-expression
     expect(result.success).to.be.true;
-    if (createMode == 'Fungible') {
+    if (createMode === 'Fungible') {
       expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);
+    } else {
+      expect(BItemCount).to.be.equal(AItemCount + 1);
     }
-    else {
-      expect(BItemCount).to.be.equal(AItemCount+1);
-    }
     expect(collectionId).to.be.equal(result.collectionId);
     expect(BItemCount).to.be.equal(result.itemId);
     newItemId = result.itemId;
@@ -358,7 +521,7 @@
     const events = await submitTransactionAsync(sender, tx);
     const result = getGenericResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect
@@ -375,7 +538,7 @@
     const events = await submitTransactionAsync(sender, tx);
     const result = getGenericResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect
@@ -392,7 +555,7 @@
     const events = await submitTransactionAsync(sender, tx);
     const result = getGenericResult(events);
 
-    // Get the collection 
+    // Get the collection
     const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
 
     // What to expect