In diesem Artikel werden die drei Kernkomponenten der Sui Move-Token analysiert: Balance (Wertspeicherebene), Coin (Token-Operationsschicht) und Pay (Ebene zur Zahlungsabstraktion). Anhand von Prinzipdiagrammen und Codebeispielen werden die Entwurfsprinzipien der dreischichtigen Architektur aufgezeigt.

| Module | Stufen | Funktion | Szenario | |: ---|: ---|: ---|: ---| | sui::balance| Wertspeicherebene (zugrundeliegender Speicher) | Verwaltung der Zuordnungsbeziehung zwischen Adressen und Token-Salden | Saldoabfrage, Überprüfung des Token-Besitzes | | sui::coin| Token-Betriebsebene (grundlegende Bedienung) | Konzentrieren Sie sich auf das Lebenszyklusmanagement des Tokens selbst; einschließlich: Token-Erstellung, -Zerstörung und Metadatenverwaltung usw. | Ausgabe benutzerdefinierter Tokens und Verwaltung der Token-Metadaten | | sui::pay| Ebene zur Zahlungsabstraktion (hochstufige Kapselung) | Stellt zusammengesetzte Operationen für Token-Zahlungen bereit, darunter: Aufteilen, Zusammenführen, Übertragen usw. von Token in einem oder mehreren Schritten | Batch-Übertragung, Split-Kontenlogik, Airdrop |

Methodendiagramm

Die Methode ist relativ einfach und ruft hauptsächlich cointhe method in balance auf. Die Methode coin wird aufgerufen, daher konzentriert sich dieser Artikel auf die dargestellte Kernmethode coin.

Die Prinzipien der Währungsregulierung werden in einem separaten Artikel vorgestellt und in diesem Artikel ignoriert.

Code-Beispiele

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)
            }
        )
    }
}