`72d901529a7b`

4 files changed

modifiedsmart_contract/ink-types-node-runtime/README.mddiff before after both

--- a/smart_contract/ink-types-node-runtime/README.md
+++ b/smart_contract/ink-types-node-runtime/README.md
@@ -30,64 +30,4 @@
 ## Test
 ```
 cargo +nightly test
-```
-
-## UI custom types
-```
-{
-  "Schedule": {
-    "version": "u32",
-    "put_code_per_byte_cost": "Gas",
-    "grow_mem_cost": "Gas",
-    "regular_op_cost": "Gas",
-    "return_data_per_byte_cost": "Gas",
-    "event_data_per_byte_cost": "Gas",
-    "event_per_topic_cost": "Gas",
-    "event_base_cost": "Gas",
-    "call_base_cost": "Gas",
-    "instantiate_base_cost": "Gas",
-    "dispatch_base_cost": "Gas",
-    "sandbox_data_read_cost": "Gas",
-    "sandbox_data_write_cost": "Gas",
-    "transfer_cost": "Gas",
-    "instantiate_cost": "Gas",
-    "max_event_topics": "u32",
-    "max_stack_height": "u32",
-    "max_memory_pages": "u32",
-    "max_table_size": "u32",
-    "enable_println": "bool",
-    "max_subject_len": "u32"
-  },
-  "CollectionMode": {
-    "_enum": {
-      "Invalid": null,
-      "NFT": "u32",
-      "Fungible": "u32",
-      "ReFungible": "(u32, u32)"
-    }
-  },
-  "NftItemType": {
-    "Collection": "u64",
-    "Owner": "AccountId",
-    "Data": "Vec<u8>"
-  },
-  "CollectionType": {
-    "Owner": "AccountId",
-    "Mode": "CollectionMode",
-    "Access": "u8",
-    "NextItemId": "u64",
-    "DecimalPoints": "u32",
-    "Name": "Vec<u16>",
-    "Description": "Vec<u16>",
-    "TokenPrefix": "Vec<u8>",
-    "CustomDataSize": "u32",
-    "OffchainSchema": "Vec<u8>",
-    "Sponsor": "AccountId",
-    "UnconfirmedSponsor": "AccountId"
-  },
-  "RawData": "Vec<u8>",
-  "Address": "AccountId",
-  "LookupSource": "AccountId",
-  "Weight": "u64"
-}
 ```
\ No newline at end of file

modifiedsmart_contract/ink-types-node-runtime/calls/lib.rsdiff before after both

--- a/smart_contract/ink-types-node-runtime/calls/lib.rs
+++ b/smart_contract/ink-types-node-runtime/calls/lib.rs
@@ -7,7 +7,7 @@
     use ink_core::env;
     use ink_prelude::vec::Vec;
     use ink_prelude::*;
-    use ink_types_node_runtime::{calls as runtime_calls, NodeRuntimeTypes};
+    use ink_types_node_runtime::{calls as runtime_calls, NodeRuntimeTypes, RawData, AccountList };
     use scale::{
         Decode,
         Encode,
@@ -29,13 +29,13 @@
         fn new(&mut self) {}
 
         #[ink(message)]
-        fn transfer(&self, collection_id: u64, item_id: u64, new_owner: AccountId) {
+        fn transfer(&self, new_owner: AccountId, collection_id: u64, item_id: u64, value: u64) {
             env::println(&format!(
-                "transfer invoke_runtime params {:?}, {:?}, {:?} ",
-                collection_id, item_id, new_owner
+                "transfer invoke_runtime params {:?}, {:?}, {:?}, {:?} ",
+                new_owner, collection_id, item_id, value
             ));
 
-            let transfer_call = runtime_calls::transfer(collection_id, item_id, new_owner);
+            let transfer_call = runtime_calls::transfer(new_owner, collection_id, item_id, value);
             // dispatch the call to the runtime
             let result = self.env().invoke_runtime(&transfer_call);
 
@@ -63,7 +63,7 @@
         }
 
         #[ink(message)]
-        fn get_approved(&self, collection_id: u64, item_id: u64) -> Vec<AccountId> {
+        fn get_approved(&self, collection_id: u64, item_id: u64) -> AccountList {
             let mut key = vec![
                 // Precomputed: Twox128("Nft")
                 244, 63, 251, 230, 30, 244, 104, 116, 157, 54, 23, 172, 26, 99, 196, 183,
@@ -92,28 +92,28 @@
             match result {
                 Some(Ok(accounts)) => { 
                     env::println(&format!("get_approved result {:?}", accounts));
-                    accounts 
+                    AccountList(accounts) 
                 },
                 Some(Err(err)) => {
                     env::println(&format!("Error reading {:?}", err));
-                    vec![]
+                    AccountList(vec![])
                 }
                 None => {
                     env::println(&format!("No data at key {:?}", key));
-                    vec![]
+                    AccountList(vec![])
                 }
             }
         }
 
         #[ink(message)]
-        fn transfer_from(&self, collection_id: u64, item_id: u64, new_owner: AccountId) {
+        fn transfer_from(&self, new_owner: AccountId, collection_id: u64, item_id: u64, value: u64) {
             env::println(&format!(
-                "transfer_from invoke_runtime params {:?}, {:?}, {:?} ",
-                collection_id, item_id, new_owner
+                "transfer_from invoke_runtime params {:?}, {:?}, {:?}, {:?} ",
+                new_owner, collection_id, item_id, value
             ));
 
             let transfer_from_call =
-                runtime_calls::transfer_from(collection_id, item_id, new_owner);
+                runtime_calls::transfer_from(new_owner, collection_id, item_id, value);
             // dispatch the call to the runtime
             let result = self.env().invoke_runtime(&transfer_from_call);
 
@@ -124,13 +124,13 @@
 
         // SafeTransferFrom
         #[ink(message)]
-        fn create_item(&self, collection_id: u64, properties: Vec<u8>, owner: AccountId) {
+        fn create_item(&self, collection_id: u64, properties: RawData, owner: AccountId) {
             env::println(&format!(
-                "create_item invoke_runtime params {:?}, {:?} ",
-                collection_id, properties
+                "create_item invoke_runtime params {:?}, {:?}, {:?} ",
+                collection_id, properties, owner
             ));
 
-            let create_item_call = runtime_calls::create_item(collection_id, properties, owner);
+            let create_item_call = runtime_calls::create_item(collection_id, properties.into(), owner);
             // dispatch the call to the runtime
             let result = self.env().invoke_runtime(&create_item_call);

modifiedsmart_contract/ink-types-node-runtime/src/calls.rsdiff before after both

--- a/smart_contract/ink-types-node-runtime/src/calls.rs
+++ b/smart_contract/ink-types-node-runtime/src/calls.rs
@@ -17,6 +17,18 @@
     }
 }
 
+// #[cfg_attr(feature = "ink-generate-abi", derive(Metadata))]
+#[derive(Encode, Decode, Debug, Eq, Clone, PartialEq)]
+pub enum CollectionMode {
+    Invalid,
+    // custom data size
+    NFT(u32),
+    // decimal points
+    Fungible(u32),
+    // custom data size and decimal points
+	ReFungible(u32, u32),
+}
+
 /// Generic Balance Call, could be used with other runtimes
 #[derive(Encode, Decode, Clone, PartialEq, Eq)]
 pub enum Nft<T>
@@ -25,19 +37,28 @@
     T::AccountId: Member + Codec,
 {
     #[allow(non_camel_case_types)]
-    create_collection(Vec<u16>, Vec<u16>, Vec<u8>, u8, u32, u32),
+    create_collection(Vec<u16>, Vec<u16>, Vec<u8>, CollectionMode),
 
     #[allow(non_camel_case_types)]
     destroy_collection(u64),
 
     #[allow(non_camel_case_types)]
+    add_collection_admin(u64, T::AccountId),
+
+    #[allow(non_camel_case_types)]
+    remove_collection_admin(u64, T::AccountId),
+
+    #[allow(non_camel_case_types)]
     change_collection_owner(u64, T::AccountId),
 
     #[allow(non_camel_case_types)]
-    add_collection_admin(u64, T::AccountId),
+    set_collection_sponsor(u64, T::AccountId),
+
+    #[allow(non_camel_case_types)]
+    confirm_sponsorship(u64),
 
     #[allow(non_camel_case_types)]
-    remove_collection_admin(u64, T::AccountId),
+    remove_collection_sponsor(u64),
 
     #[allow(non_camel_case_types)]
     create_item(u64, Vec<u8>, T::AccountId),
@@ -46,37 +67,36 @@
     burn_item(u64, u64),
 
     #[allow(non_camel_case_types)]
-    transfer(T::AccountId, u64, u64),
+    transfer(T::AccountId, u64, u64, u64),
 
     #[allow(non_camel_case_types)]
     nft_approve(T::AccountId, u64, u64),
 
     #[allow(non_camel_case_types)]
-    nft_transfer_from(T::AccountId, u64, u64),
+    nft_transfer_from(T::AccountId, u64, u64, u64),
 
     #[allow(non_camel_case_types)]
     nft_safe_transfer(u64, u64, T::AccountId),
+
+    #[allow(non_camel_case_types)]
+    set_offchain_schema(u64, Vec<u8>),
 }
 
-pub fn transfer(collection_id: u64, item_id: u64, new_owner: AccountId) -> Call {
-    Nft::<NodeRuntimeTypes>::transfer(collection_id, item_id, new_owner.into()).into()
+pub fn transfer(new_owner: AccountId, collection_id: u64, item_id: u64, value: u64) -> Call {
+    Nft::<NodeRuntimeTypes>::transfer(new_owner.into(), collection_id, item_id, value).into()
 }
 
 pub fn create_collection(
     collection_name: Vec<u16>,
     collection_description: Vec<u16>,
     token_prefix: Vec<u8>,
-    mode: u8,
-    decimal_points: u32,
-    custom_data_size: u32,
+    mode: CollectionMode
 ) -> Call {
     Nft::<NodeRuntimeTypes>::create_collection(
         collection_name,
         collection_description,
         token_prefix,
-        mode,
-        decimal_points,
-        custom_data_size,
+        mode
     )
     .into()
 }
@@ -89,8 +109,8 @@
     Nft::<NodeRuntimeTypes>::nft_approve(approved.into(), collection_id, item_id).into()
 }
 
-pub fn transfer_from(collection_id: u64, item_id: u64, new_owner: AccountId) -> Call {
-    Nft::<NodeRuntimeTypes>::nft_transfer_from(collection_id, item_id, new_owner.into()).into()
+pub fn transfer_from(new_owner: AccountId, collection_id: u64, item_id: u64, value: u64) -> Call {
+    Nft::<NodeRuntimeTypes>::nft_transfer_from(new_owner.into(), collection_id, item_id, value).into()
 }
 
 pub fn create_item(collection_id: u64, properties: Vec<u8>, owner: AccountId) -> Call {

modifiedsmart_contract/ink-types-node-runtime/src/lib.rsdiff before after both

4use ink_core::env::Clear;4use ink_core::env::Clear;
5use scale::{Decode, Encode};5use scale::{Decode, Encode};
6use sp_core::crypto::AccountId32;6use sp_core::crypto::AccountId32;
7use ink_prelude::vec::Vec;
7#[cfg(feature = "ink-generate-abi")]8#[cfg(feature = "ink-generate-abi")]
8use type_metadata::{HasTypeDef, HasTypeId, MetaType, Metadata, TypeDef, TypeId, TypeIdArray};9use type_metadata::{ HasTypeDef, HasTypeId, MetaType, Metadata, TypeDef, TypeId, TypeIdArray, TypeIdSlice};
910
10pub mod calls;11pub mod calls;
1112
46/// The default SRML balance type.47/// The default SRML balance type.
47pub type Balance = u128;48pub type Balance = u128;
49
50#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Encode, Decode)]
51pub struct AccountList(pub Vec<AccountId>);
52
53impl AccountList {
54    pub fn new(param: Vec<AccountId>) -> AccountList {
55        AccountList(param)
56    }
57}
58
59impl Into<Vec<AccountId>> for AccountList {
60    fn into(self) -> Vec<AccountId> {
61        self.0
62    }
63}
64
65#[cfg(feature = "ink-generate-abi")]
66impl HasTypeDef for AccountList {
67    fn type_def() -> TypeDef {
68        TypeDef::builtin()
69    }
70}
71
72#[cfg(feature = "ink-generate-abi")]
73impl HasTypeId for AccountList {
74    fn type_id() -> TypeId {
75        TypeIdSlice::new(AccountId::meta_type()).into()
76    }
77}
78
79
80#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Encode, Decode)]
81pub struct RawData(Vec<u8>);
82
83impl Into<Vec<u8>> for RawData {
84    fn into(self) -> Vec<u8> {
85        self.0
86    }
87}
88
89#[cfg(feature = "ink-generate-abi")]
90impl HasTypeDef for RawData {
91    fn type_def() -> TypeDef {
92        TypeDef::builtin()
93    }
94}
95
96#[cfg(feature = "ink-generate-abi")]
97impl HasTypeId for RawData {
98    fn type_id() -> TypeId {
99        TypeIdSlice::new(u8::meta_type()).into()
100    }
101}
48102
49/// The default SRML hash type.103/// The default SRML hash type.
50#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Encode, Decode)]104#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Encode, Decode)]