cleanup and refactor the code

Signed-off-by: Valentyn Faychuk <valy@faychuk.com>

Author: valentynfaychuk

contract_samples/rust/build_and_validate.sh

@@ -8,13 +8,16 @@ cargo build -p amadeus-sdk --example counter --target wasm32-unknown-unknown --r
 cargo build -p amadeus-sdk --example deposit --target wasm32-unknown-unknown --release
 cargo build -p amadeus-sdk --example coin --target wasm32-unknown-unknown --release
 cargo build -p amadeus-sdk --example nft --target wasm32-unknown-unknown --release
+cargo build -p amadeus-sdk --example showcase --target wasm32-unknown-unknown --release
 
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/counter.wasm -o counter.wasm
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/deposit.wasm -o deposit.wasm
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/coin.wasm -o coin.wasm
 wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/nft.wasm -o nft.wasm
+wasm-opt -Oz --enable-bulk-memory target/wasm32-unknown-unknown/release/examples/showcase.wasm -o showcase.wasm
 
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @counter.wasm https://mainnet-rpc.ama.one/api/contract/validate
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @deposit.wasm https://mainnet-rpc.ama.one/api/contract/validate
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @coin.wasm https://mainnet-rpc.ama.one/api/contract/validate
 curl -X POST -H "Content-Type: application/octet-stream" --data-binary @nft.wasm https://mainnet-rpc.ama.one/api/contract/validate
+curl -X POST -H "Content-Type: application/octet-stream" --data-binary @showcase.wasm https://mainnet-rpc.ama.one/api/contract/validate

contract_samples/rust/examples/showcase.rs

@@ -18,11 +18,15 @@ struct TournamentInfo {
     #[flat] prize_pool: u64,
 }
 
+type PlayerWinsMap = MapFlat<String, u32>;
+type MatchesMap = Map<u64, Match>;
+type PlayersMap = Map<String, MatchesMap>;
+
 #[contract_state]
 struct Leaderboard {
     #[flat] total_matches: i32,
-    player_wins: Map<String, u32>,
-    players: MapNested<String, MapNested<u64, Match>>,
+    player_wins: PlayerWinsMap,
+    players: PlayersMap,
     tournament: TournamentInfo,
 }
 
@@ -36,38 +40,35 @@ impl Leaderboard {
         (*self.total_matches).to_string().into_bytes()
     }
 
-    pub fn record_match(&mut self, player: String, match_id: Vec<u8>, score: Vec<u8>, opponent: String) {
-        let match_id_u64 = u64::from_bytes(match_id);
+    pub fn record_match(&mut self, player: String, match_id: u64, score: u16, opponent: String) {
         self.players.with_mut(player, |matches| {
-            matches.with_mut(match_id_u64, |m| {
-                *m.score = u16::from_bytes(score);
+            matches.with_mut(match_id, |m| {
+                *m.score = score;
                 *m.opponent = opponent;
             });
         });
         *self.total_matches += 1;
     }
 
-    pub fn get_match_score(&mut self, player: String, match_id: Vec<u8>) -> Vec<u8> {
-        let match_id_u64 = u64::from_bytes(match_id);
+    pub fn get_match_score(&mut self, player: String, match_id: u64) -> Vec<u8> {
         self.players.with_mut(player, |matches| {
-            matches.with_mut(match_id_u64, |m| {
+            matches.with_mut(match_id, |m| {
                 (*m.score).to_string().into_bytes()
             })
         })
     }
 
-    pub fn get_match_opponent(&mut self, player: String, match_id: Vec<u8>) -> String {
-        let match_id_u64 = u64::from_bytes(match_id);
+    pub fn get_match_opponent(&mut self, player: String, match_id: u64) -> String {
         self.players.with_mut(player, |matches| {
-            matches.with_mut(match_id_u64, |m| {
+            matches.with_mut(match_id, |m| {
                 (*m.opponent).clone()
             })
         })
     }
 
-    pub fn set_tournament_info(&mut self, name: String, prize_pool: Vec<u8>) {
+    pub fn set_tournament_info(&mut self, name: String, prize_pool: u64) {
         *self.tournament.name = name;
-        *self.tournament.prize_pool = u64::from_bytes(prize_pool);
+        *self.tournament.prize_pool = prize_pool;
     }
 
     pub fn get_tournament_name(&mut self) -> String {
@@ -94,7 +95,7 @@ impl Leaderboard {
         }
     }
 
-    pub fn set_player_wins(&mut self, player: String, wins: Vec<u8>) {
-        self.player_wins.insert(player, u32::from_bytes(wins));
+    pub fn set_player_wins(&mut self, player: String, wins: u32) {
+        self.player_wins.insert(player, wins);
     }
 }

contract_samples/rust/sdk-macros/src/lib.rs

@@ -17,24 +17,6 @@ pub fn contract_state(_attr: TokenStream, item: TokenStream) -> TokenStream {
         f.attrs.iter().any(|attr| attr.path().is_ident("flat"))
     };
 
-    let is_map = |f: &syn::Field| -> bool {
-        if let Type::Path(type_path) = &f.ty {
-            if let Some(segment) = type_path.path.segments.first() {
-                return segment.ident == "Map";
-            }
-        }
-        false
-    };
-
-    let is_map_nested = |f: &syn::Field| -> bool {
-        if let Type::Path(type_path) = &f.ty {
-            if let Some(segment) = type_path.path.segments.first() {
-                return segment.ident == "MapNested";
-            }
-        }
-        false
-    };
-
     let transformed_fields = fields.named.iter().map(|f| {
         let field_name = &f.ident;
         let field_vis = &f.vis;
@@ -56,45 +38,34 @@ pub fn contract_state(_attr: TokenStream, item: TokenStream) -> TokenStream {
         }
     });
 
-    let init_calls = fields.named.iter().map(|f| {
+    let init_fields = fields.named.iter().map(|f| {
         let field = f.ident.as_ref().unwrap();
+        let field_ty = &f.ty;
         let key = field.to_string();
 
         if is_flat(f) {
             quote! {
-                let mut key = prefix.clone();
-                key.extend_from_slice(#key.as_bytes());
-                self.#field = LazyCell::new(key);
-            }
-        } else if is_map(f) || is_map_nested(f) {
-            quote! {
-                let mut key = prefix.clone();
-                key.extend_from_slice(#key.as_bytes());
-                self.#field.__init_lazy_fields(key);
+                #field: {
+                    let mut key = prefix.clone();
+                    key.extend_from_slice(#key.as_bytes());
+                    LazyCell::with_prefix(key)
+                }
             }
         } else {
             quote! {
-                let mut key = prefix.clone();
-                key.extend_from_slice(#key.as_bytes());
-                key.push(b':');
-                self.#field.__init_lazy_fields(key);
+                #field: {
+                    let mut key = prefix.clone();
+                    key.extend_from_slice(#key.as_bytes());
+                    key.push(b':');
+                    #field_ty::with_prefix(key)
+                }
             }
         }
     });
 
     let flush_calls = fields.named.iter().map(|f| {
         let field = f.ident.as_ref().unwrap();
-
-        if is_flat(f) {
-            quote! { self.#field.flush(); }
-        } else {
-            quote! { self.#field.__flush_lazy_fields(); }
-        }
-    });
-
-    let default_fields = fields.named.iter().map(|f| {
-        let field_name = &f.ident;
-        quote! { #field_name: Default::default() }
+        quote! { self.#field.flush(); }
     });
 
     TokenStream::from(quote! {
@@ -103,18 +74,14 @@ pub fn contract_state(_attr: TokenStream, item: TokenStream) -> TokenStream {
             #(#transformed_fields),*
         }
 
-        impl Default for #name {
-            fn default() -> Self {
-                Self { #(#default_fields),* }
-            }
-        }
-
         impl ContractState for #name {
-            fn __init_lazy_fields(&mut self, prefix: alloc::vec::Vec<u8>) {
-                #(#init_calls)*
+            fn with_prefix(prefix: alloc::vec::Vec<u8>) -> Self {
+                Self {
+                    #(#init_fields),*
+                }
             }
 
-            fn __flush_lazy_fields(&self) {
+            fn flush(&self) {
                 #(#flush_calls)*
             }
         }
@@ -132,6 +99,21 @@ pub fn contract(_attr: TokenStream, item: TokenStream) -> TokenStream {
     item
 }
 
+fn is_integer_type(ty: &Type) -> bool {
+    if let Type::Path(type_path) = ty {
+        if let Some(segment) = type_path.path.segments.first() {
+            let ident = &segment.ident;
+            return matches!(
+                ident.to_string().as_str(),
+                "i8" | "i16" | "i32" | "i64" | "i128" |
+                "u8" | "u16" | "u32" | "u64" | "u128" |
+                "isize" | "usize"
+            );
+        }
+    }
+    false
+}
+
 fn handle_impl_block(impl_block: ItemImpl) -> TokenStream {
     let self_ty = &impl_block.self_ty;
     let mut methods = Vec::new();
@@ -154,12 +136,22 @@ fn handle_impl_block(impl_block: ItemImpl) -> TokenStream {
             .filter_map(|arg| match arg {
                 FnArg::Typed(pat_type) => {
                     let param = &pat_type.pat;
+                    let ty = &pat_type.ty;
                     let ptr = syn::Ident::new(&format!("{}_ptr", quote!(#param)), name.span());
-                    let deser = match &*pat_type.ty {
-                        Type::Path(tp) if quote!(#tp).to_string().contains("String") => quote!(read_string),
-                        _ => quote!(read_bytes),
+
+                    let deser = if let Type::Path(tp) = &**ty {
+                        if quote!(#tp).to_string().contains("String") {
+                            quote!(read_string(#ptr))
+                        } else if is_integer_type(ty) {
+                            quote!(#ty::from_bytes(read_bytes(#ptr)))
+                        } else {
+                            quote!(read_bytes(#ptr))
+                        }
+                    } else {
+                        quote!(read_bytes(#ptr))
                     };
-                    Some((quote!(#ptr: i32), quote!(let #param = #deser(#ptr);), quote!(#param)))
+
+                    Some((quote!(#ptr: i32), quote!(let #param = #deser;), quote!(#param)))
                 }
                 _ => None,
             })
@@ -184,19 +176,17 @@ fn handle_impl_block(impl_block: ItemImpl) -> TokenStream {
         let body = if has_return {
             quote! {
                 #(#deserializations)*
-                let mut state = #self_ty::default();
-                state.__init_lazy_fields(alloc::vec::Vec::new());
+                let mut state = <#self_ty as ContractState>::with_prefix(alloc::vec::Vec::new());
                 let result = state.#call;
-                state.__flush_lazy_fields();
+                state.flush();
                 ret(result);
             }
         } else {
             quote! {
                 #(#deserializations)*
-                let mut state = #self_ty::default();
-                state.__init_lazy_fields(alloc::vec::Vec::new());
+                let mut state = <#self_ty as ContractState>::with_prefix(alloc::vec::Vec::new());
                 state.#call;
-                state.__flush_lazy_fields();
+                state.flush();
             }
         };
 
@@ -228,10 +218,19 @@ fn handle_function(input: ItemFn) -> TokenStream {
     for arg in inputs.iter() {
         if let FnArg::Typed(pat_type) = arg {
             let param = &pat_type.pat;
+            let ty = &pat_type.ty;
             let ptr = syn::Ident::new(&format!("arg{}_ptr", idx), name.span());
-            let deser = match &*pat_type.ty {
-                Type::Path(tp) if quote!(#tp).to_string().contains("String") => quote!(read_string),
-                _ => quote!(read_bytes),
+
+            let deser = if let Type::Path(tp) = &**ty {
+                if quote!(#tp).to_string().contains("String") {
+                    quote!(read_string(#ptr))
+                } else if is_integer_type(ty) {
+                    quote!(#ty::from_bytes(read_bytes(#ptr)))
+                } else {
+                    quote!(read_bytes(#ptr))
+                }
+            } else {
+                quote!(read_bytes(#ptr))
             };
 
             if idx > 0 {
@@ -242,7 +241,7 @@ fn handle_function(input: ItemFn) -> TokenStream {
                 call_args.extend(quote!(#param));
             }
 
-            deserializations.extend(quote! { let #param = #deser(#ptr); });
+            deserializations.extend(quote! { let #param = #deser; });
             idx += 1;
         }
     }