Feat/sui basics

pages/Basic_Concepts/sui_move_transaction.mdx

@@ -93,6 +93,8 @@ Output của transaction bao gồm nhiều phần như:
 
 
 
+
+
 ## Lifecycle of a Transaction(optional)
 Nếu bạn thắc mắc và muốn tìm hiểu về `Lifecycle of a Transaction` từ lúc tạo ra đến lúc hoàn thành. 
 

pages/Basic_Move_Programming/Generics_and_phantom.md

@@ -0,0 +1,14 @@
+
+
+# Generic and Phantom Types (Advanced)
+
+
+
+https://yakitori.dev/blog/00-sui-move-for-solidity-devs/#hot-potato
+
+
+
+
+## Reference Type 
+Đọc thêm chi tiết ở document: https://docs.sui.io/guides/developer/sui-101/simulating-refs
+Sách: https://move-book.com/move-basics/references.html

pages/Basic_Move_Programming/Introduction to Structs.mdx

@@ -0,0 +1,4 @@
+# struct là gì 
+
+
+

pages/Basic_Move_Programming/_meta.json

@@ -1,5 +1,10 @@
 {
-  "sui_move_variable": "Sui move Variables",
-  "": ""
+  "sui_move_data_types": "Sui move data types",
+  "control_flow": "Control flow trong sui move hoạt động như thế nào ? ",
+  "function": "Function trong sui move hoạt động như thế nào ? ",
+  "struct": "Khái niệm về struct",
+  "ablities": "ablities",
+  "events_and_errors": "events và errors",
+  "unit_tests": "Viết testcase cho Sui move"
 }
-
+

pages/Basic_Move_Programming/ablities.mdx

@@ -0,0 +1,18 @@
+
+# Custom Types và  Abilities
+
+Trong trang này, bạn sẽ tìm hiểu chi tiết về các abilities trong Sui. Mỗi abilities đều sẽ có những chức năng khác nhau: 
+
+
+## Vậy chính xác thì Abilities là gì? 
+
+Trong lập trình Move, ablities giống như những quy tắc đặc biệt giúp bạn quyết định bạn sẽ làm gì với các thông tin dữ liệu như là cấp quyền(permisions) bất kì cho tài liệu đó như được chia sẻ hay edit nó.
+
+
+Đây là ví dụ là của kiểu abilities - định nghĩa một object có thể làm và có thể là: 
+```
+struct OwnerCap has key, store {
+    id: UID
+}
+```
+

pages/Basic_Move_Programming/control_flow.mdx

@@ -0,0 +1,182 @@
+
+# Control flow trong sui move hoạt động như thế nào ? 
+
+Trong trang này, bạn sẽ tìm hiểu về các control flows trong Sui. Control flow là rất quan trọng trong ngôn ngữ lập trình. Dịch ra tiếng việt là cấu trúc điều khiển flow thực thi trong chương trình bao gồm việc ra quyết định chạy, lặp lại các đoạn code hay thực thi đoạn code này sớm hơn. 
+
+## Move có các control flow statements sau: 
+1. `if` và `else` sẽ quyết định khi nào thực thi một code block trong đó.
+2. `loop` và `while` lặp lại một code block 
+3. `break` và `continue` chính là điều kiện dừng. Exit một vòng lặp sớm 
+4. `return` sẽ trả giá trị và kết thúc function sớm.
+
+Sau đây chúng ta sẽ thảo luận sâu về những statement này: 
+
+### Câu điều kiện if-else 
+
+Câu điền kiện if-else cho phép bạn chạy một đoạn code block dựa trên điều kiện mà bạn xác định là đúng(true) hay sai(false). Nếu điều kiện sai thì sẽ chuyễn đoạn block khác. Cú pháp của if-else như sau: 
+```rust
+if (<bool_expression>) {
+	<expression> 
+} else {
+	<expression>
+};
+```
+
+Ví dụ về cách if-else:
+```rust
+
+#[test] 
+    fun test_if_else(){
+        let x = 6;
+
+        // // thay vi viet nhu the nay 
+        // if(x> 0){
+        //     y = 1;
+        // } else {
+        //     y = 0;
+        // }
+
+        // ta co the viet the nay 
+
+        let y = if(x >0) {
+            43
+        } else {
+            45
+        };
+    }
+
+```
+
+
+Cùng xem ví dụ dưới đây, nếu `a` là true thì `b` sẽ lấy giá trị 10, ngược lại thì `b` sẽ lấy giá trị 20. 
+
+```rust
+
+module sui_bootcamp::example_if {
+	use sui::object::UID;
+	use sui::tx_context::{Self, TxContext};
+    use sui::transfer;
+
+	// Declaring the ExampleObject
+	public struct ExampleObject has key, store {
+		id: UID,
+		num: u8,
+	}
+
+	// Initializing the constructor
+	fun init(ctx: &mut TxContext) {
+
+		// Try switching to false
+		let a = true;
+
+		let b = if (a) {
+			10
+		} else {
+			20
+		};
+
+		let obj = ExampleObject{
+			id: object::new(ctx),
+			num: b,
+		};
+
+        transfer::public_transfer(obj, ctx.sender());
+	}
+}
+
+```
+
+### Câu lệnh lặp
+Lệnh lặp `loop` rất quan trọng vì nó sẽ giúp thực thi các tasks lặp đi lặp lại theo hướng automation. Tuy nhiên phải lưu ý khi chạy vòng lặp có thể dẫn đến vòng lặp vô hạn `infinite loop`. Nếu trên blockchain, thì chắc shắn sẽ dẫn đến việc hết phí gas vì thế mà sẽ cần các phần điều kiện để thoát khỏi vòng lặp. 
+
+Syntax loop: 
+
+```
+while (<bool_expression>) { <expressions>; };
+
+loop { <expressions>; };
+
+```
+
+```rust
+ #[test]
+    fun test_loop(mut x: u64){
+        //loop until x = 5
+        loop {
+            x = x + 1;
+
+            if (x == 5){ 
+                break  // exit 
+            }
+        }
+
+    }
+```
+
+
+
+
+### Exit khỏi vòng lặp 
+
+Một vòng lặp có thể thực thi để đạt được kết quả như kì vọng. Khi điều kiện của vòng lặp đã đạt, vòng lặp sẽ kết thúc. Để dừng vòng lặp này ta có thể sử dụng `break`. Tuy nhiên nếu chỉ muốn skip cái cái vòng lặp hiện tại và chuyển tiếp vòng lặp tiếp theo thì `continue`
+
+
+```rust
+#[test]
+    fun test_continue() {
+        let mut x = 0;
+
+        // This will loop x equals 10.
+        loop {
+            x = x + 1;
+
+            if (x % 2 == 1) {
+                continue // Skip 
+            };
+            std::debug::print(&x);
+
+            // If "x" is 10 then exit the loop.
+            if (x == 10) {
+                break // Exit loop
+            }
+        };
+    }
+```
+
+
+
+### Return 
+
+Sau khi đạt được kết quả mong muốn, bạn có thể sử dụng `return` để thoát khỏi hàm sớm và trả về một giá trị. Cú pháp như sau:
+
+```rust 
+return <expression>
+```
+
+
+
+```rust
+/// This function returns `true` if `x` is greater than 0 and not 5.
+fun is_positive(x: u8): bool {
+	if (x == 5) {
+		return false
+	};
+
+	if (x > 0) {
+		return true
+	};
+
+	false
+}
+
+```
+
+
+
+### Labels 
+Control flow có thể bị thay đổi bằng cách dùng `Labels`. Khi sử dụng `Labels`, ta có thể làm cho quá trình thực thi nhảy từ câu lệnh này sang câu lệnh khác. Labels được khai báo bằng `'label_name`:
+
+```rust
+'increment: block_of_code
+```
+

pages/Basic_Move_Programming/events_and_errors.mdx

@@ -0,0 +1,51 @@
+
+# Events là gì? 
+
+Envent là cách để module có thể tương tác với frontend qua blockchain, một thuật ngữ gọi là "listenning" cho các events và biết các action ở smart contract đang diễn ra. Nếu không có event thì sẽ rất khó để bạn có thể monitor khi mà có một object được tạo ra, được cập nhập... Event có thể query kết quả của các objects đã thay đổi như thế nào: 
+
+Mình có ví dụ tạo một ticket cho anh trai say hi 
+
+```rust
+
+module sui_bootcamp::anhtraisayhi {
+
+    use sui::object::{Self, ID, UID};
+    use sui::tx_context::{Self, TxContext};
+    use sui::transfer;
+    use sui::event;
+
+
+    public struct AnhtraisayhiTicket has key {
+        id: UID,
+
+    }
+
+    // struct ticket 
+    public struct TicketEvent has copy, drop{
+        id: ID
+    }
+
+
+    // create ticket 
+    public fun CreateTicket(ctx: &mut TxContext){
+
+        let uid = object::new(ctx);
+        let id = object::uid_to_inner(&uid);
+
+        let ticket = AnhtraisayhiTicket {
+            id: uid
+        };
+
+
+
+        transfer::transfer(ticket, tx_context::sender(ctx));
+        event::emit(TicketEvent {
+         id,
+     });
+
+    }
+
+}
+```
+
+Sử dụng lệnh `event::emit` để phát event, ta cần dùng `object::uid_to_inner` để convert từ UID type sang ID type.