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

1#![cfg_attr(not(feature = "std"), no_std)]23use ink_lang as ink;45#[ink::contract(version = "0.1.0", env = NodeRuntimeTypes)]6mod calls {7    use ink_core::env;8    use ink_prelude::vec::Vec;9    use ink_prelude::*;10    use ink_types_node_runtime::{calls as runtime_calls, NodeRuntimeTypes};11    use scale::{12        Decode,13        Encode,14    };1516    #[derive(Encode, Decode)]17    pub struct NftItemType {18        pub collection: u64,19        pub owner: AccountId,20        pub data: Vec<u8>,21    }2223    /// This simple dummy contract dispatches substrate runtime calls24    #[ink(storage)]25    struct Calls {}2627    impl Calls {28        #[ink(constructor)]29        fn new(&mut self) {}3031        #[ink(message)]32        fn transfer(&self, collection_id: u64, item_id: u64, new_owner: AccountId) {33            env::println(&format!(34                "transfer invoke_runtime params {:?}, {:?}, {:?} ",35                collection_id, item_id, new_owner36            ));3738            let transfer_call = runtime_calls::transfer(collection_id, item_id, new_owner);39            // dispatch the call to the runtime40            let result = self.env().invoke_runtime(&transfer_call);4142            // report result to console43            // NOTE: println should only be used on a development chain)44            env::println(&format!("transfer invoke_runtime result {:?}", result));45        }4647        // SafeTransfer4849        #[ink(message)]50        fn approve(&self, approved: AccountId, collection_id: u64, item_id: u64) {51            env::println(&format!(52                "approve invoke_runtime params {:?}, {:?}, {:?} ",53                approved, collection_id, item_id54            ));5556            let approve_call = runtime_calls::approve(approved, collection_id, item_id);57            // dispatch the call to the runtime58            let result = self.env().invoke_runtime(&approve_call);5960            // report result to console61            // NOTE: println should only be used on a development chain)62            env::println(&format!("approve invoke_runtime result {:?}", result));63        }6465        #[ink(message)]66        fn get_approved(&self, collection_id: u64, item_id: u64) -> Vec<AccountId> {67            let mut key = vec![68                // Precomputed: Twox128("Nft")69                244, 63, 251, 230, 30, 244, 104, 116, 157, 54, 23, 172, 26, 99, 196, 183,70                // Precomputed: Twox128("ApprovedList")71                86, 163, 236, 207, 221, 111, 252, 227, 254, 40, 142, 38, 40, 224, 192, 18,72            ];7374            let key_ext = vec![75                146, 214, 40, 117, 20, 27, 72, 25, 232, 204, 175, 194, 112, 244, 140, 100,76            ];77            key.extend_from_slice(&key_ext);7879            // collection id 80            let mut collection_bytes: Vec<u8> =  collection_id.to_be_bytes().iter().cloned().collect();81            collection_bytes.reverse();82            key.extend_from_slice(&collection_bytes.as_slice());8384             // item id 85             let mut item_bytes: Vec<u8> =  item_id.to_be_bytes().iter().cloned().collect();86             item_bytes.reverse();87             key.extend_from_slice(&item_bytes.as_slice());           8889            // fetch from runtime storage90            let result = self.env().get_runtime_storage::<Vec<AccountId>>(&key[..]);91 92            match result {93                Some(Ok(accounts)) => { 94                    env::println(&format!("get_approved result {:?}", accounts));95                    accounts 96                },97                Some(Err(err)) => {98                    env::println(&format!("Error reading {:?}", err));99                    vec![]100                }101                None => {102                    env::println(&format!("No data at key {:?}", key));103                    vec![]104                }105            }106        }107108        #[ink(message)]109        fn get_test(&self) -> bool {110            true111        }112113        #[ink(message)]114        fn transfer_from(&self, collection_id: u64, item_id: u64, new_owner: AccountId) {115            env::println(&format!(116                "transfer_from invoke_runtime params {:?}, {:?}, {:?} ",117                collection_id, item_id, new_owner118            ));119120            let transfer_from_call =121                runtime_calls::transfer_from(collection_id, item_id, new_owner);122            // dispatch the call to the runtime123            let result = self.env().invoke_runtime(&transfer_from_call);124125            // report result to console126            // NOTE: println should only be used on a development chain)127            env::println(&format!("transfer_from invoke_runtime result {:?}", result));128        }129130        // SafeTransferFrom131132        #[ink(message)]133        fn create_item(&self, collection_id: u64, properties: Vec<u8>) {134            env::println(&format!(135                "create_item invoke_runtime params {:?}, {:?} ",136                collection_id, properties137            ));138139            let create_item_call = runtime_calls::create_item(collection_id, properties);140            // dispatch the call to the runtime141            let result = self.env().invoke_runtime(&create_item_call);142143            // report result to console144            // NOTE: println should only be used on a development chain)145            env::println(&format!("create_item invoke_runtime result {:?}", result));146        }147148        #[ink(message)]149        fn burn_item(&self, collection_id: u64, item_id: u64) {150            env::println(&format!(151                "burn_item invoke_runtime params {:?}, {:?}",152                collection_id, item_id153            ));154155            let burn_item_call = runtime_calls::burn_item(collection_id, item_id);156            // dispatch the call to the runtime157            let result = self.env().invoke_runtime(&burn_item_call);158159            // report result to console160            // NOTE: println should only be used on a development chain)161            env::println(&format!("burn_item invoke_runtime result {:?}", result));162        }163164        // GetOwner165        #[ink(message)]166        fn get_owner(&self, collection_id: u64, token_id: u64) -> AccountId {167            let mut key = vec![168                // Precomputed: Twox128("Nft")169                244, 63, 251, 230, 30, 244, 104, 116, 157, 54, 23, 172, 26, 99, 196, 183,170                // Precomputed: Twox128("ItemList")171                116, 232, 175, 181, 237, 113, 149, 125, 139, 77, 55, 251, 115, 253, 29, 240,172            ];173174            let key_ext = vec![175                146, 214, 40, 117, 20, 27, 72, 25, 232, 204, 175, 194, 112, 244, 140, 100,176            ];177            key.extend_from_slice(&key_ext);178179            // collection id 180            let mut collection_bytes: Vec<u8> =  collection_id.to_be_bytes().iter().cloned().collect();181            collection_bytes.reverse();182            key.extend_from_slice(&collection_bytes.as_slice());183184             // token id 185             let mut token_bytes: Vec<u8> =  token_id.to_be_bytes().iter().cloned().collect();186             token_bytes.reverse();187             key.extend_from_slice(&token_bytes.as_slice());           188189            // fetch from runtime storage        190            let result = self.env().get_runtime_storage::<NftItemType>(&key[..]);191 192            match result {193                Some(Ok(item)) => { 194                    env::println(&format!("get_owner result {:?}", item.owner));195                    item.owner196                },197                Some(Err(err)) => {198                    env::println(&format!("Error reading {:?}", err));199                    AccountId::from([0u8; 32])200                }201                None => {202                    env::println(&format!("No data at key {:?}", key));203                    AccountId::from([0u8; 32])204                }205            }206        }207208        #[ink(message)]209        fn get_balance_of(&self, collection_id: u64, owner: AccountId) -> u64 {210            let mut key = vec![211                // Precomputed: Twox128("Nft")212                244, 63, 251, 230, 30, 244, 104, 116, 157, 54, 23, 172, 26, 99, 196, 183,213                // Precomputed: Twox128("Balance")214                78, 168, 234, 12, 1, 250, 164, 43, 110, 179, 68, 168, 92, 71, 179, 135,215            ];216217            let key_ext = vec![218                15, 97, 136, 0, 76, 187, 168, 28, 239, 85, 170, 23, 77, 81, 248, 159,219            ];220            key.extend_from_slice(&key_ext);221222            // collection id 223            let mut collection_bytes: Vec<u8> =  collection_id.to_be_bytes().iter().cloned().collect();224            collection_bytes.reverse();225            key.extend_from_slice(&collection_bytes.as_slice());226227             // owner228             key.extend_from_slice(&owner.encode());           229230            // fetch from runtime storage231            let result = self.env().get_runtime_storage::<u64>(&key[..]);232 233            match result {234                Some(Ok(balance)) => { 235                    env::println(&format!("get_balance_of result {:?}", balance));236                    balance237                },238                Some(Err(err)) => {239                    env::println(&format!("Error reading {:?}", err));240                    0241                }242                None => {243                    env::println(&format!("No data at key {:?}", key));244                    0245                }246            }247        }248    }249}