Kiểu giá trị (Value types)

INT / UINT

uint là viết tắt của unsigned integer (số nguyên không dấu), bạn có thể chọn kích thước từ uint8 đến uint256

uint8 từ 0 đến 2 ** 8 - 1
uint16 từ 0 đến 2 ** 16 - 1
...
uint256 từ 0 đến 2 ** 256 - 1

uint8 public u8 = 1;
uint256 public u256 = 456;
uint public u = 123; // uint là viết tắt của uint256

int là viết tắt của integer (số nguyên có dấu), bạn có thể chọn kích thước từ int8 đến int256

int8 từ -2 ** 7 đến 2 ** 7 - 1
int16 từ -2 ** 15 đến 2 ** 15 - 1 ...
int128 từ -2 ** 127 đến 2 ** 127 - 1
int256 từ -2 ** 255 đến 2 ** 255 - 1

int8 public i8 = -1;
int256 public i256 = 456;
int public i = -123; // int là viết tắt của int256

// giá trị nhỏ nhất và lớn nhất của kiểu int: 
int public minInt = type(int).min;
int public maxInt = type(int).max;
 
// giá trị nhỏ nhất và lớn nhất của kiểu uint:
uint public minUint = type(uint).min;
uint public maxUint = type(uint).max;

BOOL và toán tử

bool là kiểu Boolean, chỉ có 2 giá trị là true (đúng) và false (sai)
! (phủ định logic)
&& (và logic)
|| (hoặc logic)
== (so sánh bằng)
!= (so sánh khác)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
contract AccessControl {
    bool public isAdmin = false;
    bool public isActive = true;
 
    // Hàm để cấp quyền admin cho người gọi
    function grantAdmin() public {
        require(!isAdmin, "Already admin");
        isAdmin = true;
    }
 
    // Hàm để thu hồi quyền admin
    function revokeAdmin() public {
        require(isAdmin && isActive, "Must be active admin");
        isAdmin = false;
    }
 
    // Hàm kiểm tra quyền và trạng thái
    function canAccess() public view returns (bool) {
        return isAdmin && isActive;
    }
 
    function isNotAdmin() public view returns (bool) {
        return isAdmin != true;
    }
 
    // Hàm tắt kích hoạt
    function deactivate() public {
        require(isActive == true, "Already inactive");
        isActive = false;
    }
}

ADDRESS

address là kiểu dữ liệu đặc biệt trong Solidity, lưu trữ 20 bytes (kích thước) địa chỉ của một tài khoản EVM
address payable tương tự như address nhưng có thêm 2 phương thức transfer và send

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
contract EtherTransfer {
    address public receiver;
    address payable public payableReceiver;
 
    constructor() {
        receiver = 0xAb8483F64d9C6d1EcF9b849Ae677dD3315835Cb2;
        payableReceiver = payable(0xAb8483F64d9C6d1EcF9b849Ae677dD3315835Cb2);
    }
 
    // Trả về số dư (wei) của địa chỉ ví
    function checkBalance() public view returns (uint) {
        return receiver.balance;
    }
 
    // Gửi Ether bằng transfer (không khuyến nghị)
    function sendWithTransfer() public payable {
        require(msg.value > 0, "Must send some Ether");
        payableReceiver.transfer(msg.value);
    }
 
    // Gửi Ether bằng send (ít dùng)
    function sendWithSend() public payable {
        require(msg.value > 0, "Must send some Ether");
        bool success = payableReceiver.send(msg.value);
        require(success, "Send failed");
    }
 
    // Gửi Ether bằng call (được khuyến nghị)
    function sendWithCall() public payable {
        require(msg.value > 0, "Must send some Ether");
        (bool success, ) = payableReceiver.call{value: msg.value}("");
        require(success, "Call failed");
    }
 
    // Hàm fallback để nhận Ether
    receive() external payable {}
}

BYTES

Trong Solidity, kiểu dữ liệu byte đại diện cho một chuỗi các byte. Solidity có hai loại bytes:

Mảng byte kích thước cố định
Mảng byte kích thước động

Từ khóa bytes trong Solidity đại diện cho một mảng động các byte. Thực chất, nó là viết tắt của byte[].

bytes1 a = 0xb5; //  [10110101]
bytes1 b = 0x56; //  [01010110]
bytes c = "abc"; //  [01100001, 01100010, 01100011]

GIÁ TRỊ MẶC ĐỊNH

Các biến được khai báo mà không gán giá trị sẽ có giá trị mặc định.

bool public defaultBool; // false
uint public defaultUint; // 0
int public defaultInt; // 0
address public defaultAddr; // 0x0000000000000000000000000000000000000000
bytes1 public defaultByte; // 0x00

ENUM

Enums là một cách để tạo kiểu dữ liệu do người dùng định nghĩa trong Solidity.

Chúng có thể chuyển đổi tường minh sang và từ các kiểu số nguyên, nhưng không cho phép chuyển đổi ngầm định.
Việc chuyển đổi tường minh từ số nguyên sẽ kiểm tra giá trị có nằm trong phạm vi của enum không, nếu không sẽ gây ra lỗi Panic.
Enums yêu cầu ít nhất một thành viên, và giá trị mặc định khi khai báo là thành viên đầu tiên.
Enum không thể có quá 256 thành viên.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
contract PaymentStatus {
    // Enum đại diện cho trạng thái thanh toán
    enum PaymentState {
        Unpaid, // 0 
        Pending, // 1
        Paid, // 2
        Refunded // 3
    }
 
    PaymentState public payment;
 
    // Cập nhật trạng thái thanh toán
    function setPaymentState(PaymentState _state) public {
        payment = _state;
    }
 
    // Đánh dấu thanh toán đã được hoàn tất
    function markAsPaid() public {
        payment = PaymentState.Paid;
    }
 
    // Kiểm tra nếu đã thanh toán
    function isPaid() public view returns (bool) {
        return payment == PaymentState.Paid;
    }
 
    // Hoàn tiền
    function refund() public {
        require(payment == PaymentState.Paid, "Only paid orders can be refunded");
        payment = PaymentState.Refunded;
    }
 
    // Reset về trạng thái ban đầu
    function resetPayment() public {
        delete payment;
    }
}

Solidity Basics 02 - Main Contract Structure Solidity Basics 04 - Call contract