feat: completed basic contract

pages/_meta.json

@@ -2,11 +2,11 @@
   "index": "What is Movement?",
   "aptos": "What is Aptos?",
   "movement": "Movement Technical Details",
-  "movement_framework" : "Movement Framework (Coming Soon)",
-  "interoperability_security": "Interoperability & Security (Coming Soon)",
   "move_solidity" : "Move vs Solidity",
   "move_language_basic" : "Move Language Basic",
   "move_language_advanced" : "Move Language Advanced",
+  "aptos_move" : "Aptos Move",
+  "swap_contract" : "Swap Contract",
   "rakiapp": {
     "title": "Movement with Aptos Workshop ↗",
     "type": "page",

pages/aptos_move/_meta.json

@@ -0,0 +1,5 @@
+{
+  "aptos_account" : "Aptos Account",
+  "aptos_coin" : "Aptos Coin",
+  "object" : "Object"
+}

pages/aptos_move/aptos_account.mdx

@@ -0,0 +1,64 @@
+# Aptos Account
+## Cấu trúc Address
+
+Address trong Aptos là một chuỗi 32-byte, thường được biểu diễn dưới dạng 64 ký tự hex. Mỗi ký tự hex đại diện cho một nibble (4 bit).
+
+### Ví dụ:
+- Alice: `0xeeff357ea5c1a4e7bc11b2b17ff2dc2dcca69750bfef1e1ebcaccf8c8018175b`
+- Bob: `0x19aadeca9388e009d136245b9a67423f3eee242b03142849eb4f81a4a409e59c`
+
+## Tiền tố và số 0 đứng đầu
+1. address có thể có tiền tố `0x` để chỉ ra rằng đó là một số hex.
+2. Các số 0 đứng đầu có thể được bỏ qua khi hiển thị, nhưng vẫn là một phần của address 32-byte đầy đủ.
+
+### Ví dụ với số 0 đứng đầu:
+- Dan: `0000357ea5c1a4e7bc11b2b17ff2dc2dcca69750bfef1e1ebcaccf8c8018175b`
+- Dan: `0x0000357ea5c1a4e7bc11b2b17ff2dc2dcca69750bfef1e1ebcaccf8c8018175b`
+- Dan: `0x357ea5c1a4e7bc11b2b17ff2dc2dcca69750bfef1e1ebcaccf8c8018175b`
+
+Tất cả các biểu diễn trên đều chỉ cùng một address.
+
+## Tạo address
+address tài khoản được tạo từ khóa xác thực ban đầu, theo quy trình sau:
+  1. Tạo cặp khóa công khai/riêng tư.
+  2. Kết hợp khóa công khai với scheme chữ ký để tạo khóa xác thực 32-byte.
+  3. Sử dụng khóa xác thực này làm address tài khoản.
+
+## Xử lý address trong code
+
+Khi làm việc với address trong code, nhà phát triển nên lưu ý:
+
+1. Luôn xử lý address dưới dạng 32-byte đầy đủ.
+2. Khi hiển thị cho người dùng, có thể bỏ qua các số 0 đứng đầu để dễ đọc hơn.
+3. Khi nhận đầu vào từ người dùng, hãy chấp nhận cả dạng đầy đủ và dạng rút gọn, sau đó chuẩn hóa về dạng 32-byte.
+
+## Ví dụ xử lý address trong Move
+
+```move
+use std::address;
+
+fun process_address(addr: address) {
+    // address luôn là 32-byte trong Move
+    // Không cần xử lý đặc biệt
+}
+
+fun display_address(addr: address): String {
+    // Chuyển đổi address thành chuỗi và loại bỏ số 0 đứng đầu
+    let addr_str = address::to_string(addr);
+    // Lưu ý: Đây chỉ là ví dụ, Move không có kiểu String nguyên thủy
+    // Bạn cần implement hàm remove_leading_zeros
+    remove_leading_zeros(addr_str)
+}
+```
+
+## Address Short
+Aptos cũng hỗ trợ address ngắn hơn 32-byte. Trong trường hợp này:
+- address sẽ được tự động điền thêm số 0 ở đầu để đạt đủ 32-byte.
+- Ví dụ: 0x1 sẽ được xử lý như 0x0000000000000...01
+
+Nhà phát triển nên cẩn thận khi xử lý address ngắn và đảm bảo rằng chúng được chuẩn hóa đúng cách trước khi sử dụng.
+
+## Bảo mật và address
+- address không phải là private, nhưng nó là định danh duy nhất của tài khoản.
+- Không nên sử dụng address làm seed để tạo khóa riêng tư.
+- Luôn xác minh address khi nhận từ đầu vào người dùng để tránh các cuộc tấn công liên quan đến address không hợp lệ.

pages/aptos_move/aptos_coin.mdx

@@ -0,0 +1,171 @@
+# Aptos Coin
+
+[Coin](https://github.com/aptos-labs/aptos-core/blob/main/aptos-move/framework/aptos-framework/sources/coin.move) cung cấp một framework tiêu chuẩn, an toàn về kiểu cho các token hoặc coin fungible đơn giản.
+
+## Structure
+
+### Reusability
+
+Một coin được định nghĩa trong Move như sau:
+
+```rust
+struct Coin<phantom CoinType> has store {
+    /// Số lượng coin mà địa chỉ này có.
+    value: u64,
+}
+```
+
+Coin sử dụng `CoinType` để hỗ trợ tái sử dụng framework Coin cho các Coin riêng biệt. Ví dụ, `Coin<A>` và `Coin<B>` là hai coin khác nhau.
+
+### Kho lưu trữ toàn cục
+Coin cũng hỗ trợ một resource để lưu trữ coin trong kho lưu trữ toàn cục:
+
+```rust
+struct CoinStore<phantom CoinType> has key {
+    coin: Coin<CoinType>,
+    frozen: bool,
+    deposit_events: EventHandle<DepositEvent>,
+    withdraw_events: EventHandle<WithdrawEvent>,
+}
+```
+
+Thông tin hoặc metadata của coin được lưu trữ trong global storage dưới tài khoản của người tạo coin:
+```rust
+struct CoinInfo<phantom CoinType> has key {
+    name: string::String,
+    /// Ký hiệu của coin, thường là phiên bản ngắn hơn của tên.
+    /// Ví dụ, Singapore Dollar là SGD.
+    symbol: string::String,
+    /// Số lượng số thập phân được sử dụng để hiển thị cho người dùng.
+    /// Ví dụ, nếu `decimals` bằng `2`, số dư `505` coin sẽ
+    /// được hiển thị cho người dùng là `5.05` (`505 / 10 ** 2`).
+    decimals: u8,
+    /// Số lượng của loại coin này đang tồn tại.
+    supply: Option<OptionalAggregator>,
+}
+```
+
+## Tạo một CoinType mới
+
+Người tạo coin có thể publish lên một account on-chain một module mới định nghĩa một struct để đại diện cho một `CoinType` mới. Người tạo coin sau đó sẽ gọi `coin:initialize<CoinType>` từ tài khoản đó để đăng ký nó như một coin hợp lệ, và nhận lại các struct cho phép gọi các function để đốt(burn) và tạo(mint) coin cũng như đóng băng (freeze) `CoinStore`. Những struct này cần được lưu trữ trong global storage bởi người tạo để quản lý việc sử dụng coin.
+
+```rust
+public fun initialize<CoinType>(
+    account: &signer,
+    name: string::String,
+    symbol: string::String,
+    decimals: u8,
+    monitor_supply: bool,
+): (BurnCapability<CoinType>, FreezeCapability<CoinType>, MintCapability<CoinType>) {
+```
+
+- Ba tham số đầu tiên (`name`, `symbol`, `decimals`) chỉ là metadata và không ảnh hưởng đến các ứng dụng on-chain. Một số ứng dụng có thể sử dụng decimal để quy đổi một Coin đơn vị thành phân số coin.
+- Theo dõi nguồn cung (`monitor_supply`) giúp theo dõi tổng số coin trong lưu thông. Tuy nhiên, do cách thức hoạt động của bộ thực thi song song, bật tùy chọn này sẽ ngăn chặn bất kỳ việc thực thi song song nào của mint và burn. Nếu coin sẽ được tạo hoặc đốt thường xuyên, hãy cân nhắc tắt `monitor_supply`.
+
+## Tạo Coin (Mint)
+Nếu người tạo hoặc quản lý muốn tạo coin, họ phải lấy tham chiếu đến `MintCapability` của họ, được tạo ra trong `initialize`, và gọi:
+
+```rust
+public fun mint<CoinType>(
+    amount: u64,
+    _cap: &MintCapability<CoinType>,
+): Coin<CoinType> acquires CoinInfo {
+```
+
+Điều này sẽ tạo ra một struct Coin mới chứa giá trị được xác định bởi `amount`.
+
+## Đốt Coin (Burn)
+Nếu người tạo hoặc quản lý muốn đốt coin, họ phải lấy tham chiếu đến `BurnCapability` của họ, được tạo ra trong `initialize`, và gọi:
+
+```rust
+public fun burn<CoinType>(
+    coin: Coin<CoinType>,
+    _cap: &BurnCapability<CoinType>,
+) acquires CoinInfo {
+```
+
+Người tạo hoặc quản lý cũng có thể đốt coin từ một `CoinStore`:
+
+```rust
+public fun burn_from<CoinType>(
+    account_addr: address,
+    amount: u64,
+    burn_cap: &BurnCapability<CoinType>,
+) acquires CoinInfo, CoinStore {
+```
+
+## Đóng băng tài khoản (Freeze)
+
+Nếu người tạo hoặc quản lý muốn đóng băng một `CoinStore` trên một tài khoản cụ thể, họ phải lấy tham chiếu đến `FreezeCapability` của họ, được tạo ra trong `initialize`, và gọi:
+
+```rust
+public entry fun freeze_coin_store<CoinType>(
+    account_addr: address,
+    _freeze_cap: &FreezeCapability<CoinType>,
+) acquires CoinStore {
+```
+
+## Gộp Coin (Merge)
+Hai coin cùng loại có thể được gộp thành một struct Coin duy nhất đại diện cho tổng giá trị của hai coin độc lập bằng cách gọi:
+
+```rust
+public fun merge<CoinType>(
+    dst_coin: &mut Coin<CoinType>,
+    source_coin: Coin<CoinType>,
+) {
+```
+
+## Trích xuất Coin (Extract)
+Một Coin có thể bị trừ giá trị để tạo ra một Coin khác bằng cách gọi:
+
+```rust
+public fun extract<CoinType>(
+        coin: &mut Coin<CoinType>,
+        amount: u64,
+): Coin<CoinType> {
+```
+
+## Rút Coin từ CoinStore (Withdraw)
+Người nắm giữ `CoinStore` có thể trích xuất một Coin với giá trị được chỉ định bằng cách gọi:
+
+```rust
+public fun withdraw<CoinType>(
+    account: &signer,
+    amount: u64,
+): Coin<CoinType> acquires CoinStore {
+```
+
+## Gửi Coin vào CoinStore (Deposit)
+Bất kỳ thực thể nào cũng có thể gửi coin vào `CoinStore` của một tài khoản bằng cách gọi:
+
+```rust
+public fun deposit<CoinType>(
+        account_addr: address,
+        coin: Coin<CoinType>,
+) acquires CoinStore {
+```
+
+## Chuyển Coin (Transfer)
+Người nắm giữ `CoinStore` có thể trực tiếp chuyển coin từ tài khoản của họ sang `CoinStore` của tài khoản khác bằng cách gọi:
+
+```rust
+public entry fun transfer<CoinType>(
+    from: &signer,
+    to: address,
+    amount: u64,
+) acquires CoinStore {
+```
+
+## Sự kiện (Event)
+
+```rust
+struct DepositEvent has drop, store {
+    amount: u64,
+}
+```
+
+```rust
+struct WithdrawEvent has drop, store {
+    amount: u64,
+}
+```

pages/aptos_move/object.mdx

@@ -0,0 +1,86 @@
+# Object
+
+## Mô hình Object
+
+Mô hình Object cho phép Move biểu diễn một kiểu dữ liệu phức tạp như một tập hợp các tài nguyên được lưu trữ trong một địa chỉ duy nhất. Nó cung cấp một mô hình khả năng phong phú, cho phép kiểm soát tài nguyên chi tiết và quản lý quyền sở hữu linh hoạt.
+
+## Các đặc điểm của mô hình Object
+
+1. Giao diện lưu trữ đơn giản hóa: Hỗ trợ lưu trữ một tập hợp các tài nguyên không đồng nhất cùng nhau. Điều này cho phép các kiểu dữ liệu chia sẻ một lớp dữ liệu cơ bản chung (ví dụ: tokens), trong khi vẫn có thể mở rộng phong phú hơn (ví dụ: vé concert, thanh kiếm).
+
+2. Mô hình dữ liệu và quyền sở hữu có thể truy cập toàn cầu: Cho phép người tạo và nhà phát triển quyết định việc áp dụng và vòng đời của dữ liệu.
+
+3. Mô hình lập trình có thể mở rộng: Hỗ trợ cá nhân hóa các ứng dụng người dùng tận dụng framework cốt lõi, bao gồm cả tokens.
+
+4. Hỗ trợ phát sự kiện trực tiếp: Cải thiện khả năng phát hiện các sự kiện liên quan đến objects.
+
+5. Tối ưu hóa hiệu suất hệ thống: Sử dụng nhóm tài nguyên để tối ưu hóa gas, tránh chi phí deserialization và serialization đắt đỏ, và hỗ trợ khả năng xóa.
+
+Object là một primitive cốt lõi trong Aptos Move và được tạo thông qua module object tại địa chỉ 0x1::object.
+
+## Ví dụ mã
+
+Dưới đây là một ví dụ về cách sử dụng Object trong Aptos Move:
+
+```move
+module my_addrx::MyFriends
+{
+    use std::vector;
+    use aptos_std::object::{Self,Object};
+    use std::signer;
+    use aptos_framework::account;
+
+    struct MyFriends has key
+    {
+        friends: vector<vector<u8>>,
+    }
+
+    // Hàm tạo danh sách bạn bè
+    public entry fun create_friends(caller: &signer, list:vector<vector<u8>> ) : Object<MyFriends>
+    {
+        let myfriend_constructor_ref = object::create_object_from_account(caller);
+        let myfriend_signer = object::generate_signer(&myfriend_constructor_ref);
+        move_to(&myfriend_signer, MyFriends{ friends:list });
+        let obj = object::object_from_constructor_ref<MyFriends>(&myfriend_constructor_ref);
+        return obj
+    }
+
+    // Hàm chuyển quyền sở hữu object
+    public entry fun transferring_of_ownership(from: &signer,to: address,obj: Object<MyFriends>) : address
+    {
+        object::transfer(from,obj,to); // Chuyển quyền sở hữu của object
+        let new_owner_of_the_object = object::owner(obj); // Quyền sở hữu được theo dõi trên chính object
+        return new_owner_of_the_object
+    }
+
+    // Hàm kiểm tra
+    #[test(owner = @0x123)]
+    public entry fun test_flow(owner: signer)
+    {
+        account::create_account_for_test(signer::address_of(&owner));
+
+        // Tạo danh sách bạn bè
+        let list = vector::empty<vector<u8>>();
+        vector::push_back(&mut list, b"John");
+        vector::push_back(&mut list, b"Harry");
+        vector::push_back(&mut list, b"Gwen");
+        let obj = create_friends(&owner,list);
+
+        assert!(signer::address_of(&owner) == @0x123,1);
+
+        // Chuyển quyền sở hữu của object từ tài khoản chủ sở hữu sang tài khoản 0x345
+        let new_owner_address = transferring_of_ownership(&owner,@0x345,obj);
+
+        assert!(new_owner_address == @0x345,1);
+    }
+}
+```
+
+Trong ví dụ này:
+
+1. Chúng ta định nghĩa một struct `MyFriends` để lưu trữ danh sách bạn bè.
+2. Hàm `create_friends` tạo một Object mới chứa danh sách bạn bè.
+3. Hàm `transferring_of_ownership` cho phép chuyển quyền sở hữu của Object từ một tài khoản sang tài khoản khác.
+4. Hàm `test_flow` kiểm tra quá trình tạo Object và chuyển quyền sở hữu.
+
+Mô hình Object trong Aptos Move cung cấp một cách linh hoạt và mạnh mẽ để quản lý dữ liệu phức tạp và quyền sở hữu trong các ứng dụng blockchain.

pages/move_language_advanced/_meta.json

@@ -1,14 +1,9 @@
 {
   "global_storage_structure" : "Global Storage Structure",
-  "global_storage_operations" : "Global Storage Operations",
+  "
+global_storage_operations" : "Global Storage Operations",
   "phantom_type_parameters" : "Phantom Type Parameters",
-  "timestamps" : "Timestamps",
   "ownership" : "Ownership",
   "move_coding_conventions" : "Move Coding Conventions",
   "view_function" : "View Function",
-  "aptos_account" : "Aptos Account",
-  "aptos_coin" : "Aptos Coin",
-  "aptos_token_nft" : "Aptos Token (NFT)",
-  "object" : "Object",
-  "token_v2" : "Token V2"
 }