Bài viết này phân tích ba thành phần cốt lõi của token Sui Move: số dư (lớp lưu trữ giá trị), coin (lớp hoạt động token) và pay (lớp trừu tượng thanh toán). Thông qua sơ đồ nguyên tắc và ví dụ mã, các nguyên tắc thiết kế của kiến trúc ba lớp được tiết lộ.

| Mô-đun | Bậc | Chức năng | Kịch bản | |: ------|: ---|: ---| | sui::balance| Lớp lưu trữ giá trị (lưu trữ cơ bản) | Quản lý mối quan hệ ánh xạ giữa địa chỉ và số dư token | Truy vấn số dư, xác minh quyền sở hữu token | | sui::coin| Lớp hoạt động mã thông báo (hoạt động cơ bản) | Tập trung vào quản lý vòng đời của chính mã thông báo; bao gồm: tạo mã thông báo, phá hủy và quản lý siêu dữ liệu, v.v. | Phát hành mã thông báo tùy chỉnh và duy trì siêu dữ liệu token | | sui::pay| Lớp trừu tượng thanh toán (đóng gói cấp cao) | Cung cấp các hoạt động ghép cho thanh toán mã thông báo bao gồm: tách mã thông báo đơn hoặc hàng loạt, hợp nhất, chuyển, v.v. | Chuyển hàng loạt, logic tài khoản chia nhỏ, airdrop |

Sơ đồ phương pháp

Phương pháp này tương đối đơn giản, chủ yếu gọi cointhe method in balance. Phương pháp coin sẽ được gọi vào, vì vậy bài viết này tập trung vào đồng tiền phương pháp cốt lõi được minh họa.

Các nguyên tắc của tiền tệ quy định sẽ được giới thiệu trong một bài viết riêng và sẽ bị bỏ qua trong bài viết này.

Ví dụ về mã

module cookbook::aig_token {
    use std::string::{Self, String};
    use std::ascii;
    use sui::coin::{Self, TreasuryCap};
    use sui::balance::{Self, Balance};
    use sui::url::{Self, Url};
    use sui::event;

    public struct EventMint has copy, drop {
        sender: address,
        amount: u64,
        coin_left: u64
    }

    public struct EventAirdrop has copy, drop {
        method: String,
        sender: address,
        amount: u64
    }

    public struct EventCoinMeta has copy, drop {
        decimals: u8,
        symbol: ascii::String,
        name: String,
        description: String,
        icon_url: Option<Url>,
    }

    public struct EventTotalSupply has copy, drop {
        total_supply: u64
    }

    public struct Vault has key {
        id: UID,
        balance: Balance<AIG_TOKEN>,
    }

    public struct AIG_TOKEN has drop {}

    fun init(
        witness: AIG_TOKEN,
        ctx: &mut TxContext
    ) {

        let decimals = 3;
        let symbol = b"AIG";
        let name = b"AIG Token";
        let description = b"AIG Token is a token that is used to incentivize the community to achieve the goals of the AI Goal.";
        let url = url::new_unsafe_from_bytes(b"https://ai-goal.vercel.app/");

        let (treasury_cap, metadata) = coin::create_currency<AIG_TOKEN>(
            witness,
            decimals,
            symbol,
            name,
            description,
            option::some(url),
            ctx
        );

        event::emit(
            EventCoinMeta {
                decimals: coin::get_decimals(&metadata),
                symbol: coin::get_symbol(&metadata),
                name: coin::get_name(&metadata),
                description: coin::get_description(&metadata),
                icon_url: option::some(url),
            }
        );

        transfer::public_freeze_object(metadata);
        transfer::public_transfer(treasury_cap, ctx.sender());

        transfer::share_object(
            Vault {
                id: object::new(ctx),
                balance: balance::zero(),
            }
        );
    }

    public(package) fun airdrop(
        vault: &mut Vault,
        amount: u64,
        method: vector<u8>,
        ctx: &mut TxContext
    ) {
        let sender = ctx.sender();

        let mut balance_drop = balance::split(&mut vault.balance, amount);
        let coin_drop = coin::take(&mut balance_drop, amount, ctx);
        transfer::public_transfer(coin_drop, sender);
        balance::destroy_zero(balance_drop);

        event::emit(
            EventAirdrop {
                method: string::utf8(method),
                sender,
                amount,
            }
        );
    }

    public fun mint_balance(
        treasury_cap: &mut TreasuryCap<AIG_TOKEN>,
        vault: &mut Vault,
        amount: u64,
        ctx: &mut TxContext
    ) {
        let balance_minted = coin::mint_balance(treasury_cap, amount);
        balance::join(&mut vault.balance, balance_minted);

        event::emit(
            EventMint {
                sender: ctx.sender(),
                amount: amount,
                coin_left: balance::value(&vault.balance)
            }
        );
    }

    #[allow(lint(self_transfer))]
    public fun mint_coin(
        treasury_cap: &mut TreasuryCap<AIG_TOKEN>,
        amount: u64,
        ctx: &mut TxContext
    ) {
        let coin_minted = coin::mint(treasury_cap, amount, ctx);
        transfer::public_transfer(coin_minted, ctx.sender());

        coin::mint_and_transfer(
            treasury_cap,
            amount,
            ctx.sender(),
            ctx
        );

        event::emit(
            EventTotalSupply {
                total_supply: coin::total_supply(treasury_cap)
            }
        )
    }
}