Lisk Smart Contract
Solidity Basics 03 - Types of Variables

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 transfersend
// 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;
    }
}