completed smart contract section

contracts/01-tamagotchi/io/src/lib.rs

@@ -1,7 +1,7 @@
 #![no_std]
 
 use codec::{Decode, Encode};
-use gmeta::Metadata;
+use gmeta::{Metadata, In, InOut, Out};
 use gstd::prelude::*;
 use scale_info::TypeInfo;
 
@@ -10,29 +10,34 @@ use scale_info::TypeInfo;
 #[scale_info(crate = gstd::scale_info)]
 pub struct Tamagotchi {
     // TODO: 1️⃣ Add `name` and `age` fields
+    pub name: String,
+    pub date_of_birth: u64,
 }
 
 #[derive(Encode, Decode, TypeInfo)]
 #[codec(crate = gstd::codec)]
 #[scale_info(crate = gstd::scale_info)]
 pub enum TmgAction {
-    // TODO: 2️⃣ Add `Name` and `Age` actions that set the name and age
+    Name,
+    Age,
 }
 
 #[derive(Encode, Decode, TypeInfo)]
 #[codec(crate = gstd::codec)]
 #[scale_info(crate = gstd::scale_info)]
 pub enum TmgEvent {
     // TODO: 3️⃣ Add `Name` and `Age` events that return the name and age
+    Name(String),
+    Age(u64),
 }
 
 pub struct ProgramMetadata;
 
 // TODO: 4️⃣ Fill `Init`, `Handle`, and `State` types
 impl Metadata for ProgramMetadata {
-    type Init = ();
-    type Handle = ();
-    type State = ();
+    type Init = In<String>;
+    type Handle = InOut<TmgAction, TmgEvent>;
+    type State = Out<Tamagotchi>;
     type Reply = ();
     type Others = ();
     type Signal = ();

contracts/01-tamagotchi/src/lib.rs

@@ -1,19 +1,62 @@
 #![no_std]
 
 #[allow(unused_imports)]
-use gstd::prelude::*;
+use gstd::{prelude::*, debug, exec, msg};
+use tamagotchi_io::{Tamagotchi, TmgAction, TmgEvent};
+
+
+
+static mut STATE: Option<Tamagotchi> = None;
 
 #[no_mangle]
 extern fn init() {
     // TODO: 5️⃣ Initialize the Tamagotchi program
+   let name: String = msg::load().expect("Cant decode the tamagotchi name");
+
+   let tamagotchi = Tamagotchi {
+        name,
+        date_of_birth: exec::block_timestamp(),
+   };
+
+   debug!("Program was initialized with Tamagotchi {:?}", tamagotchi);
+   unsafe {STATE = Some(tamagotchi)};
 }
 
 #[no_mangle]
-extern fn handle() {
-    // TODO: 6️⃣ Add handling of `Name` and `Age` actions
+extern "C" fn handle() {
+    let action: TmgAction = msg::load().expect("Unable to decode incoming TmgAction");
+
+    let state = unsafe {
+        STATE.as_ref().expect("The contract is not initialized")
+    };
+
+    match action {
+        TmgAction::Name => {
+            debug!("Tamagotchi: Name Requested");
+            // Directly reply with the name, as TmgAction::Name does not carry data
+            msg::reply(TmgEvent::Name(state.name.clone()), 0)
+                .expect("Error handling Tamagotchi name");
+        }
+        TmgAction::Age => {
+            debug!("Tamagotchi: Age Requested");
+            // Directly reply with the date of birth, as TmgAction::Age does not carry data
+            msg::reply(TmgEvent::Age(state.date_of_birth), 0)
+                .expect("Error handling Tamagotchi age");
+        }
+    }
 }
 
+
+
 #[no_mangle]
 extern fn state() {
     // TODO: 7️⃣ Return the Tamagotchi state
+    let tomagotchi = unsafe {
+        STATE
+            .as_ref()
+            .expect("The contract is not initialized")
+    };
+    if let Err(e) = msg::reply(tomagotchi, 0) {
+        debug!("Failed to send state: {:?}", e);
+    }
 }

contracts/01-tamagotchi/tests/smoke.rs

@@ -1,10 +1,28 @@
-use gtest::{Program, System};
+use gtest::{Log, Program, System};
+use tamagotchi_io::{TmgAction, TmgEvent};
 
 #[test]
 fn smoke_test() {
     let sys = System::new();
     sys.init_logger();
-    let _program = Program::current(&sys);
+    let program = Program::current(&sys);
 
     // TODO: 8️⃣ Test the program initialization and message handling
+    let tamagotchi_name = String::from("Keno");
+    let initialize_contract = program.send(2, tamagotchi_name.clone());
+
+    assert!(!initialize_contract.main_failed(), "init function failed");
+
+    let get_name_action = TmgAction::Name;
+    let get_name_result = program.send(3, get_name_action);
+
+    assert!(!get_name_result.main_failed(), "Name request failed");
+
+    let expected_tamagatchi = Log::builder()
+        .dest(3)
+        .payload(TmgEvent::Name(String::from("Keno")));
+
+    assert!(get_name_result.contains(&expected_tamagatchi));
+
+
 }