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

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2553,6 +2553,7 @@
  "pallet-balances",
  "pallet-contracts",
  "pallet-contracts-primitives",
+ "pallet-contracts-rpc-runtime-api",
  "pallet-grandpa",
  "pallet-nft",
  "pallet-randomness-collective-flip",

--- a/node/src/chain_spec.rs
+++ b/node/src/chain_spec.rs
@@ -103,7 +103,8 @@
 fn testnet_genesis(initial_authorities: Vec<(AuraId, GrandpaId)>,
 	root_key: AccountId,
 	endowed_accounts: Vec<AccountId>,
-	_enable_println: bool) -> GenesisConfig {
+	_enable_println: bool
+	) -> GenesisConfig {
 	GenesisConfig {
 		system: Some(SystemConfig {
 			code: WASM_BINARY.to_vec(),
@@ -122,9 +123,9 @@
 			key: root_key,
 		}),
 		contracts: Some(ContractsConfig {
-			gas_price: 1_000_000_000,
+			gas_price: 1_000,
             current_schedule: ContractsSchedule {
-                 //   enable_println,
+            		// enable_println,
                     ..Default::default()
             },
         }),

--- a/node/src/service.rs
+++ b/node/src/service.rs
@@ -25,6 +25,7 @@
 /// be able to perform chain operations.
 macro_rules! new_full_start {
 	($config:expr) => {{
+		use jsonrpc_core::IoHandler;
 		use std::sync::Arc;
 		let mut import_setup = None;
 		let inherent_data_providers = sp_inherents::InherentDataProviders::new();
@@ -62,7 +63,15 @@
 				import_setup = Some((grandpa_block_import, grandpa_link));
 
 				Ok(import_queue)
-			})?;
+			})?
+			.with_rpc_extensions(|builder| -> Result<IoHandler<sc_rpc::Metadata>, _> {
+                let handler = pallet_contracts_rpc::Contracts::new(builder.client().clone());
+                let delegate = pallet_contracts_rpc::ContractsApi::to_delegate(handler);
+
+                let mut io = IoHandler::default();
+                io.extend_with(delegate);
+                Ok(io)
+            })?;
 
 		(builder, import_setup, inherent_data_providers)
 	}}

24pub struct CollectionType<AccountId> {24pub struct CollectionType<AccountId> {
25    pub owner: AccountId,25    pub owner: AccountId,
26    pub next_item_id: u64,26    pub next_item_id: u64,
27    pub name: Vec<u16>, // 64 include null escape char
28    pub description: Vec<u16>, // 256 include null escape char
29    pub token_prefix: Vec<u8>, // 16 include null escape char
27    pub custom_data_size: u32,30    pub custom_data_size: u32,
28}31}
2932
59        /// Next available collection ID62        /// Next available collection ID
60        pub NextCollectionID get(fn next_collection_id): u64;63        pub NextCollectionID get(fn next_collection_id): u64;
61
62        pub Collection get(collection): map hasher(identity) u64 => CollectionType<T::AccountId>;64        pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;
63        //pub Collection get(collection): map hasher(identity) u64 => CollectionType<T::AccountId>;
64
65        pub AdminList get(admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;65        pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;
6666
67        /// Balance owner per collection map67        /// Balance owner per collection map
68        pub Balance get(balance_count): map hasher(blake2_128_concat) (u64, T::AccountId) => u64;68        pub Balance get(fn balance_count): map hasher(blake2_128_concat) (u64, T::AccountId) => u64;
69        pub ApprovedList get(approved): map hasher(blake2_128_concat) (u64, u64) => Vec<T::AccountId>;69        pub ApprovedList get(fn approved): map hasher(blake2_128_concat) (u64, u64) => Vec<T::AccountId>;
7070
71        pub ItemList get(item_id): map hasher(blake2_128_concat) (u64, u64) => NftItemType<T::AccountId>;71        pub ItemList get(fn item_id): map hasher(blake2_128_concat) (u64, u64) => NftItemType<T::AccountId>;
72        // pub ItemList get(item_id): map hasher(blake2_128_concat) (u64, u64) => NftItemType<T::AccountId>;
73
74        pub ItemListIndex get(item_index): map hasher(blake2_128_concat) u64 => u64;72        pub ItemListIndex get(fn item_index): map hasher(blake2_128_concat) u64 => u64;
75        // pub ItemListIndex get(item_index): map hasher(blake2_128_concat) u64 => u64;73
74        pub AddressTokens get(fn address_tokens): map hasher(blake2_128_concat) (u64, T::AccountId) => Vec<u64>;
76    }75    }
77}76}
7877
82    where81    where
83        AccountId = <T as system::Trait>::AccountId,82        AccountId = <T as system::Trait>::AccountId,
84    {83    {
85        Created(u32, AccountId),84        Created(u64, AccountId),
85        ItemCreated(u64),
86        ItemDestroyed(u64, u64),
86    }87    }
87);88);
8889
110        // returns collection ID111        // returns collection ID
111        #[weight = frame_support::weights::SimpleDispatchInfo::default()]112        #[weight = frame_support::weights::SimpleDispatchInfo::default()]
112        pub fn create_collection(origin, custom_data_sz: u32) -> DispatchResult {113        pub fn create_collection(   origin, 
114                                    collection_name: Vec<u16>, 
115                                    collection_description: Vec<u16>, 
116                                    token_prefix: Vec<u8>, 
117                                    custom_data_sz: u32) -> DispatchResult {
118
113            // Anyone can create a collection119            // Anyone can create a collection
114            let who = ensure_signed(origin)?;120            let who = ensure_signed(origin)?;
121
122            // check params 
123            let mut name = collection_name.to_vec();
124            name.push(0);
125            ensure!(name.len() <= 64, "Collection name can not be longer than 63 char");
126
127            let mut description = collection_description.to_vec();
128            description.push(0);
129            ensure!(name.len() <= 256, "Collection description can not be longer than 255 char");
130
131            let mut prefix = token_prefix.to_vec();
132            prefix.push(0);
133            ensure!(prefix.len() <= 16, "Token prefix can not be longer than 15 char");
115134
116            // Generate next collection ID135            // Generate next collection ID
117            let next_id = NextCollectionID::get();136            let next_id = NextCollectionID::get()
137                .checked_add(1)
138                .expect("collection id error");
118139
119            NextCollectionID::put(next_id);140            NextCollectionID::put(next_id);
120141
121            // Create new collection142            // Create new collection
122            let new_collection = CollectionType {143            let new_collection = CollectionType {
123                owner: who,144                owner: who.clone(),
145                name: name,
146                description: description,
147                token_prefix: prefix,
124                next_item_id: next_id,148                next_item_id: next_id,
125                custom_data_size: custom_data_sz,149                custom_data_size: custom_data_sz,
126            };150            };
127151
128            // Add new collection to map152            // Add new collection to map
129            <Collection<T>>::insert(next_id, new_collection);153            <Collection<T>>::insert(next_id, new_collection);
154
155            // call event
156            Self::deposit_event(RawEvent::Created(next_id, who.clone()));
130157
131            Ok(())158            Ok(())
132        }159        }
276
249277
250            let current_index = <ItemListIndex>::get(collection_id);278            let current_index = <ItemListIndex>::get(collection_id)
279                .checked_add(1)
280                .expect("Item list index id error");
281
282            Self::add_token_index(collection_id, current_index, new_item.owner.clone())?;
283
251            <ItemListIndex>::insert(collection_id, current_index);284            <ItemListIndex>::insert(collection_id, current_index);
252            <ItemList<T>>::insert((collection_id, current_index), new_item);285            <ItemList<T>>::insert((collection_id, current_index), new_item);
286
287            // call event
288            Self::deposit_event(RawEvent::ItemCreated(collection_id));
253289
254            Ok(())290            Ok(())
255        }291        }
279            }315            }
280            <ItemList<T>>::remove((collection_id, item_id));316            <ItemList<T>>::remove((collection_id, item_id));
317
318            Self::remove_token_index(collection_id, item_id, item.owner.clone())?;
281319
282            // update balance320            // update balance
283            let new_balance = <Balance<T>>::get((collection_id, item.owner.clone())) - 1;321            let new_balance = <Balance<T>>::get((collection_id, item.owner.clone())) - 1;
284            <Balance<T>>::insert((collection_id, item.owner.clone()), new_balance);322            <Balance<T>>::insert((collection_id, item.owner.clone()), new_balance);
323
324            // call event
325            Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));
285326
286            Ok(())327            Ok(())
287        }328        }
319            <Balance<T>>::insert((collection_id, new_owner.clone()), balance_new_owner);360            <Balance<T>>::insert((collection_id, new_owner.clone()), balance_new_owner);
320361
321            // change owner362            // change owner
322            item.owner = new_owner;363            let old_owner = item.owner.clone();
364            item.owner = new_owner.clone();
323            <ItemList<T>>::insert((collection_id, item_id), item);365            <ItemList<T>>::insert((collection_id, item_id), item);
366
367            // update index collection
368            Self::move_token_index(collection_id, item_id, old_owner, new_owner.clone())?;
324369
325            // reset approved list370            // reset approved list
326            let itm: Vec<T::AccountId> = Vec::new();371            let itm: Vec<T::AccountId> = Vec::new();
403}448}
404449
450
451impl<T: Trait> Module<T> {
452    fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {
453        
454        let list_exists = <AddressTokens<T>>::contains_key((collection_id, owner.clone()));
455        if list_exists {
456
457            let mut list = <AddressTokens<T>>::get((collection_id, owner.clone()));
458            let item_contains = list.contains(&item_index.clone());
459
460            if !item_contains {
461                list.push(item_index.clone());
462            }
463
464            <AddressTokens<T>>::insert((collection_id, owner.clone()), list);
465
466        } else {
467
468            let mut itm = Vec::new();
469            itm.push(item_index.clone());
470            <AddressTokens<T>>::insert((collection_id, owner), itm);
471        }
472
473        Ok(())
474    }
475
476    fn remove_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {
477        
478        let list_exists = <AddressTokens<T>>::contains_key((collection_id, owner.clone()));
479        if list_exists {
480
481            let mut list = <AddressTokens<T>>::get((collection_id, owner.clone()));
482            let item_contains = list.contains(&item_index.clone());
483
484            if item_contains {
485                list.retain(|&item| item != item_index);
486                <AddressTokens<T>>::insert((collection_id, owner), list);
487            }
488        }
489
490        Ok(())
491    }
492
493    fn move_token_index(collection_id: u64, item_index: u64, old_owner: T::AccountId, new_owner: T::AccountId) -> DispatchResult {
494        
495        Self::remove_token_index(collection_id, item_index, old_owner)?;
496        Self::add_token_index(collection_id, item_index, new_owner)?;
497        
498        Ok(())
499    }
500}

--- a/pallets/nft/src/tests.rs
+++ b/pallets/nft/src/tests.rs
@@ -5,9 +5,14 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
+        assert_ok!(TemplateModule::create_collection(origin1.clone(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), size));
         assert_eq!(TemplateModule::collection(1).owner, 1);
     });
 }
@@ -15,10 +20,15 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
+        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,
@@ -31,10 +41,15 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
+        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));
     });
 }
@@ -42,11 +57,16 @@
 #[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();
+
         let size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
+        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(),
@@ -62,11 +82,16 @@
 #[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();
+
         let size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
+        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(),
@@ -91,14 +116,19 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -116,14 +146,19 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -149,14 +184,19 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -181,14 +221,19 @@
 #[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();
+
         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(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -214,14 +259,19 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -243,14 +293,19 @@
 #[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();
+
         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(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -272,14 +327,19 @@
 #[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 size = 1024;
         let origin1 = Origin::signed(1);
         let origin2 = Origin::signed(2);
         let origin3 = Origin::signed(3);
 
-        assert_ok!(TemplateModule::create_collection(origin1.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin2.clone(), size));
-        assert_ok!(TemplateModule::create_collection(origin3.clone(), size));
+        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(2).owner, 2);
@@ -297,3 +357,50 @@
         assert_ok!(TemplateModule::transfer_from(origin1.clone(), 1, 1, 2));
     });
 }
+
+#[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();
+
+        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(), 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(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);
+    });
+}
+

--- a/runtime/Cargo.toml
+++ b/runtime/Cargo.toml
@@ -24,6 +24,11 @@
 package = 'pallet-contracts-primitives'
 version = '2.0.0-alpha.6'
 
+[dependencies.contracts-rpc-runtime-api]
+default-features = false
+package = 'pallet-contracts-rpc-runtime-api'
+version = '0.8.0-alpha.6'
+
 [dependencies.frame-executive]
 default-features = false
 version = '2.0.0-alpha.6'
@@ -143,8 +148,9 @@
     'aura/std',
     'balances/std',
     'codec/std',
-    'contracts/std',
-    'contracts-primitives/std',
+	"contracts/std",
+	"contracts-primitives/std",
+	"contracts-rpc-runtime-api/std",
     'frame-executive/std',
     'frame-support/std',
     'grandpa/std',

--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -36,6 +36,9 @@
 pub use sp_runtime::{Perbill, Permill};
 pub use timestamp::Call as TimestampCall;
 pub use contracts::Schedule as ContractsSchedule;
+pub use contracts_rpc_runtime_api::{
+	self as runtime_api, ContractExecResult
+};
 
 /// Importing a template pallet
 pub use nft;
@@ -403,4 +406,39 @@
             Grandpa::grandpa_authorities()
         }
     }
+
+    impl contracts_rpc_runtime_api::ContractsApi<Block, AccountId, Balance, BlockNumber>
+        for Runtime
+	{
+		fn call(
+			origin: AccountId,
+			dest: AccountId,
+			value: Balance,
+			gas_limit: u64,
+			input_data: Vec<u8>,
+		) -> ContractExecResult {
+			let exec_result =
+				Contracts::bare_call(origin, dest.into(), value, gas_limit, input_data);
+			match exec_result {
+                Ok(v) => ContractExecResult::Success {
+                    status: v.status,
+                    data: v.data,
+                },
+				Err(_) => ContractExecResult::Error,
+			}
+		}
+
+		fn get_storage(
+			address: AccountId,
+			key: [u8; 32],
+		) -> contracts_primitives::GetStorageResult {
+			Contracts::get_storage(address, key)
+		}
+
+		fn rent_projection(
+			address: AccountId,
+		) -> contracts_primitives::RentProjectionResult<BlockNumber> {
+			Contracts::rent_projection(address)
+		}
+	}
 }