Merge pull request #23 from vbi-academy/feat/objects

Object centric model

pages/object_programming/Intro_object_centric_design.mdx

@@ -0,0 +1,41 @@
+> Trong computing, tất cả mọi thứ chỉ là bits và bytes đều có thể dễ dàng copied. Nhưng chúng ta cần **một ngôn ngữ lập trình có tính quyền sở hữu( ownership) **, tương tự như cách hoạt động của các objects trong thế giới thực. Điều này rất quan trọng vì lý do bảo mật. Đó là lý do tại sao chúng tôi đã tạo ra Move - một ngôn ngữ lập trình mới giải quyết vấn đề này. Các ngôn ngữ lập trình khác, n**gay cả những ngôn ngữ được sử dụng cho các ứng dụng blockchain,** không xử lý vấn đề này. Sui xây dựng Move đặc biệt để giúp các lập trình viên viết code bảo mật hơn, dễ dàng hơn, mà không cần phải tạo ra các giải pháp phức tạp từ đầu **—**  
+> 
+**Lời văn từ Sam Blackshear -** Creator of the Move programming language, Co-founder of Mysten Labs, Initial Contributor to Sui ( https://blog.sui.io/power-of-sui-move/ )
+
+
+<br/>
+
+Như giới thiệu từ section 1, Move, ban đầu được phát triển bởi Meta, là một ngôn ngữ lập trình được thiết kế cho **blockchain** và **smart contracts**, khởi đầu để **hỗ trợ dự án Libra** (sau đổi tên thành Diem). Thiết kế và triển khai của Move chịu ảnh hưởng từ ngôn ngữ Rust và có các kiểu dữ liệu nguyên thủy (primitive types) và mảng (arrays). Theo **Sam Blackshea**r - creator của Move lang, ngôn ngữ Move giải quyết các vấn đề sau: 
+
+- **Tính sở hữu và  khan hiếm(Ownership và Scarcity)**: Move cung cấp các trừu tượng (abstractions) cần thiết để biểu diễn bits và bytes trong máy tính, giúp chúng có tính chất sở hữu và khan hiếm như các vật thể trong thế giới thực.
+- **Đảm bảo Bảo mật**: Move được thiết kế với các đảm bảo bảo mật cơ bản, cho phép dev viết code an toàn và hiệu quả mà không cần phải "phát minh lại bánh xe".
+- **Hệ thống Kiểu Resource**: Hệ thống kiểu resource đảm bảo các tài nguyên không thể bị sao chép hoặc xóa bỏ và chỉ có thể được quản lý thông qua các transfer được phép.
+
+Move trên Sui là ngôn ngữ lập trình smart contract được phát triển bởi Mysten Labs cho blockchain Sui. Đây là phiên bản cải tiến của Move, được thiết kế để tích hợp với mô hình dữ liệu hướng đối tượng của Sui.
+
+Sơ đồ dưới đây sẽ  thể hiện sự tiến hoá của ngôn ngữ Move: 
+
+
+![](../assets/Objects/move_evolution.png)
+
+## Các thành phần của một object trong object-centric data model?
+
+**Resource-Oriented Design Concept:** Sự độc đáo của Sui nằm ở thiết kế hướng tài nguyên (resource-oriented). Thiết kế này xem các tài nguyên **on-chain** như những objects có thể quản lý độc lập, cho phép sử dụng hiệu quả và quản lý chính xác các tài nguyên.
+
+- **Objects**: Trong Sui, mỗi tài nguyên on-chain được xem như một object. Các objects này có thể là **tokens**, **smart contracts**, **NFTs**, hoặc các loại tài sản khác.
+- **State và lifecycle của Objects**: Mỗi object có state và lifecycle riêng. Trạng thái của object có thể được thay đổi bởi các transactions hoặc smart contracts, trong khi vòng đời của nó định nghĩa quá trình tạo, sử dụng và hủy object đó.
+
+<br/> 
+
+Trong Sui, tất cả các transactions đều yêu cầu objects làm input và tạo ra các objects mới hoặc đã được chỉnh sửa làm output. Mỗi object lưu trữ hash của transaction cuối cùng đã tạo ra nó. Những objects có thể được sử dụng làm input được gọi là "active" objects. Bằng cách quan sát các active objects này, chúng ta có thể hiểu được trạng thái hiện tại của toàn bộ blockchain: 
+
+- **Unique Identifier (objectId):** Mỗi object có một định danh duy nhất để phân biệt với các objects khác. ID này được tạo ra khi object được khởi tạo và không thể thay đổi (immutable)
+- **Object Type (objType)**: Mỗi object có một kiểu xác định cấu trúc và hành vi của nó.
+- **Owner (owner)**: Mỗi object gắn với một chủ sở hữu có quyền kiểm soát object đó. Trên Sui, objects có thể được sở hữu bởi một tài khoản, được chia sẻ giữa tất cả tài khoản, hoặc bị đóng băng - chỉ cho phép truy cập đọc mà không được sửa đổi hay transfer.
+- **Version**: Mỗi khi object thay đổi trong Sui, một số phiên bản mới được tạo ra, đóng vai trò như một số ngẫu nhiên để ngăn chặn các tấn công replay.
+- **Digest**: Mỗi object có một digest - một hash của dữ liệu object. Digest được dùng để xác minh tính toàn vẹn của dữ liệu object và đảm bảo nó không bị can thiệp. Digest được tính khi object được tạo và được cập nhật khi dữ liệu object thay đổi.
+- **Content Fields**: Đây là vùng có kích thước thay đổi theo danh mục, chứa dữ liệu được mã hóa bằng Binary Canonical Serialization (BCS), ghi lại dữ liệu cụ thể của object.
+
+
+![](../assets/Objects/coin_example.png)
+

pages/object_programming/_meta.json

@@ -0,0 +1,6 @@
+{
+  "Intro_object_centric_design": "Object centric Model",
+  "what_is_object": "Object là gì",
+  "object_ownership": "object ownership"
+}
+

pages/object_programming/object_ownership.mdx

@@ -0,0 +1,148 @@
+# Object Ownership 
+
+Mỗi object đều có một trường chủ sở hữu(owner field) cho biết object này đang được sở hữu như thế nào. Quyền ownershiop quy định cách một đối tượng có thể được sử dụng trong các transaction. Có các  loại object:
+
+1. Address-owner 
+3. Immutable
+3. Share
+4. Wrapped object - Dynamic fields
+
+## Owned by an address
+
+**Object thuộc sở hữu của address** là object được sở hữu bởi một địa chỉ 32-byte, có thể là địa chỉ account hoặc ID của một object khác. Chỉ có chủ sở hữu mới có quyền truy cập vào object đó. Có hai cách để tạo ra một object thuộc sở hữu của địa chỉ. Khi một đối tượng Move được tạo ra, nó có thể được chuyển cho một địa chỉ. Sau đó, địa chỉ này sẽ trở thành chủ sở hữu( owner) của object đó.  Chỉ có owner mới có thể sử dụng đối tượng của mình trong các transaction sigend. Khi sử dụng, đối tượng có thể được truyền vào theo 3 cách:
+
+- read-only reference (&T)
+- mutable reference (`&mut T`) và
+- by-value (`T`)
+
+Đây làm một số cách để bạn tạo một address-owned object: 
+```rust 
+sui::transfer::transfer(obj: T, recipient: address)
+sui::transfer::public_transfer(obj: T, recipient: address)
+```
+
+## Immutable objects 
+
+Sau khi được tạo ra, trạng thái của các đối tượng này không thể thay đổi. Chúng không thể bị sửa đổi, transfer, hoặc xóa và không có chủ sở hữu( ownership), nghĩa là bất kỳ ai cũng có thể sử dụng object này. Các đối tượng immutable sẽ cung cấp tính bền vững và độ tin cậy, phù hợp với dữ liệu cần duy trì không đổi theo thời gian. Ví dụ như metadata của token Coin trên Sui, nơi mà các thông tin như tên, ký hiệu và số thập phân cần được cố định ngay từ khi tạo ra. 
+
+Đây là function giúp tạo một object immutable: 
+
+```rust
+public native fun public_freeze_object(obj: T)
+
+// ta sẽ dùng 
+transfer::freeze_object(obj);
+```
+
+Sau lệnh gọi này, `obj` sẽ trở thành bất biến( immutable) , nghĩa là bạn không thể sửa đổi hoặc xóa nó. Quá trình này cũng không thể đảo ngược: một khi object đã bị frozen, nó sẽ mãi mãi ở trạng thái đó. Bất kỳ ai cũng có thể sử dụng đối tượng bất biến này như một tham chiếu trong lệnh call Move.
+
+→ Tất cả các packages và modules đã được publish trong Sui đều là immutable objects
+
+Bạn có thể đọc thêm tài liệu về immutable: https://docs.sui.io/concepts/object-ownership/immutable 
+
+## Shared object
+
+Như vậy immutable object trên ở cũng có thể coi là **Shared object.** Nhưng sự khác biệt là Shared object có thể được read và mutabed ( thay đổi) được bởi bất kì ai).
+
+Để tạo share object thì ta cần phải gọi: 
+
+```rust
+transfer::share_object(obj);
+```
+
+Khi một object được chia sẻ, nó vẫn có thể thay đổi được và bất kỳ ai cũng có thể truy cập để gửi transaction chỉnh sửa object đó.
+Share object vẫn sẽ có UID của mình. Ví dụ: 
+```rust
+public struct SharedObject has key {
+   id: UID,
+}
+```
+
+
+Ta có thể create object: 
+```rust 
+public fun convert_to_share_object(object: SharedObject) {
+ transfer::share_object(object);
+}
+
+// hoặc là 
+
+public fun create_shared_object(ctx: &mut TxContext) {
+ let shared_object = SharedObject {
+     id: object::new(ctx),
+ };
+	 convert_to_share_object(shared_object);
+}
+
+```
+
+`Share_object<T: key>(obj: T)`: method này biến một object có key thành shared và chỉ có thể được sử dụng trong module nơi object được định nghĩa. Nếu object không được tạo ra trong transaction hiện tại thì thao tác sẽ abort.
+
+
+```rust
+public fun share_object<T: key>(obj: T) {
+    share_object_impl(obj)
+}
+```
+
+Ngoài ra chúng ta còn có `public_share_object<T: key + store>(obj: T)` một function tương tự với `share_object` nhưng sẽ có thêm store cho phép object share với các module khác.
+
+⇒ Các bạn sẽ có thắc mắc là sự tương đồng và khác nhau giữa Immutable và share object là gì ? Giữa Freeze và Share khác nhau chỗ nào? 
+
+## Trade-Offs giữa Shared và Owned Objects
+
+- Đối với **owned object**: Xử lý nhanh hơn vì không cần qua quá trình đồng thuận( consesus). Tuy nhiên, có hai hạn chế:
+    - Chỉ chủ sở hữu mới có thể sử dụng object, nên khó thực hiện các giao dịch cần nhiều người tham gia
+    - Khi nhiều người muốn truy cập cùng một object thường xuyên (hot object), việc điều phối phải thực hiện bên ngoài blockchain
+
+- **Shared Objects**  Việc sử dụng shared object trong các transaction yêu cầu i phải đồng thuận(consensus) về cách đọc và write chúng. Điều này có nghĩa là bạn sẽ phải trả nhiều phí gas hơn một chút và đợi lâu hơn một chút để giao dịch hoàn tất.  Khi nhiều người cùng cố gắng sử dụng các shared object một lúc, thời gian chờ có thể sẽ còn lâu hơn nữa. Tuy nhiên, lợi ích là shared object mang lại cho bạn nhiều sự linh hoạt hơn trong cách sử dụng.
+
+Như vậy **Điểm tương đồng**: Cả hai đều thay đổi trạng thái của object, làm cho nó immutable ở một mức độ nào đó. Cả hai đều có abilities là  **key và store**, được sử dụng cho các thao tác bên trong và bên ngoài module.
+
+**Điểm khác biệt**: freeze làm cho object hoàn toàn bất biến( immutable), không cho phép bất kỳ hình thức transfer hay modify nào. Có thể hiểu đây là **chia sẻ bất biến( immutable sharing)**. Ngược lại, share  object làm cho object được chia sẻ, cho phép tất cả người dùng truy cập và sửa đổi. Có thể hiểu đây là **mutable sharing** .
+
+Ví dụ: 
+
+```rust 
+module sui_boootcamp::transfer_example_a {
+    public struct Object_share has key, store { id: UID }
+}
+
+module sui_boootcamp::transfer_example_b {
+		// import 
+    use sui_boootcamp::transfer_example_a ::{Object_share};
+
+    // Fails!  bởi vì Object share ko nằm trong intenrl 
+        public fun transfer_ks(ks: Object_share, to: address) {
+        transfer::transfer(ks, to);
+    }
+
+    // Works! Object_share is not internal but the function is public
+    public fun public_transfer_ks(y: Object_share, to: address) {
+        transfer::public_transfer(y, to);
+    }
+```
+
+## **Wrapped Objects ( hay Owned by another object)**
+
+**Wrapped Objects**: Các object trong Sui không tồn tại độc lập; chúng có thể được nhóm lại với nhau để đáp ứng các trường hợp sử dụng phức tạp. 
+
+Wrapped objects là ví dụ về điều này, khi được chứa bởi một object khác. Sui cũng hỗ trợ **Dynamic Object Fields**, cho phép các object nhúng các object khác vào trong nó, từ đó cho phép xây dựng các logic và cấu trúc dữ liệu phức tạp hơn.
+
+Quyền sở hữu của wrapped objects được xác định bởi object đang chứa chúng, tạo ra một cách tiếp cận linh hoạt trong việc quản lý object.
+
+```rust 
+struct Foo has key {
+    id: UID,
+    bar: Bar,
+}
+
+struct Bar has store {
+    value: u64,
+}
+
+```
+
+Đối tượng Sui `Foo` với khả năng `key` có một instance `bar` với kiểu dữ liệu `Bar`, là một `struct`. Ở đây, `Bar` không phải là một đối tượng Sui vì nó không có `key` abilities  . Bạn có thể biến nó thành một đối tượng Sui và sử dụng nó trong `Foo`.
+
+Trong bài học sắp tới bạn sẽ học về dynamic object field. Đơn giản là chúng ta gọi object được sỡ hữu bởi object khác thì là object con( child).