easy-peasy

Object-Centric Design

In Sui Move, everything revolves around objects , which are unique, immutable, or mutable entities stored directly on-chain. This contrasts sharply with account-based models in traditional smart contract languages, where balances and states are tied to addresses. Objects in Sui are:

Typed and Resource-Oriented : Resources (like tokens or NFTs) are first-class citizens, ensuring they cannot be duplicated, unintentionally destroyed, or misused. Owned and Transferable : Each object has a clear owner, making it easier to enforce permissions and prevent unauthorized access.

module examples::my_token { use sui::object::{Self, UID}; use sui::transfer;

// Define a custom object type
struct MyToken has key, store {
    id: UID,
    value: u64,
}

// Function to create a new token
public fun create_token(ctx: &mut TxContext): MyToken {
    MyToken {
        id: object::new(ctx),
        value: 100,
    }
}

// Function to transfer ownership of the token
public fun transfer_token(token: MyToken, recipient: address) {
    transfer::public_transfer(token, recipient);
}

}

Example demonstrates how Sui Move ensures secure object creation and ownership. The MyToken object is explicitly owned and cannot be duplicated due to Move's type system.

Module Encapsulation and Access Control

Sui Move enforces strict encapsulation at the module level. Functions and resources defined within a module are private by default, and only explicitly marked functions are accessible externally. This minimizes the attack surface for malicious actors.

module examples::secure_module { use sui::object::{Self, UID};

// Private struct (only accessible within the module)
struct SecretData has key {
    id: UID,
    data: vector<u8>,
}

// Public function to create a secret object
public fun create_secret(ctx: &mut TxContext): SecretData {
    SecretData {
        id: object::new(ctx),
        data: b"confidential".to_vec(),
    }
}

// Private function (not callable outside the module)
fun internal_logic(secret: &SecretData): u64 {
    secret.data.length()
}

}

Here, SecretData and internal_logic are inaccessible outside the module, ensuring that sensitive logic remains protected.