SUI Token Explained

1 SUI = 1,000,000,000 MIST (10^9)

public struct Coin<phantom T> has key, store {
    id: UID,
    balance: Balance<T>,
}

pub fn new_gas_coin(version: SequenceNumber, id: ObjectID, value: u64) -> Self {
    unsafe {
        Self::new_from_execution_with_limit(
            GasCoin::type_().into(),
            true,
            version,
            GasCoin::new(id, value).to_bcs_bytes(),
            256,
        )
        .unwrap()
    }
}

Max Supply: 10,000,000,000 SUI

import { Transaction } from '@mysten/sui/transactions';

const tx = new Transaction();

// Split 1 SUI into separate coin
const [coin] = tx.splitCoins(tx.gas, [1_000_000_000]); // 1 SUI in MIST

tx.transferObjects([coin], recipient);

const tx = new Transaction();

// Merge all coins into primary coin
tx.mergeCoins(primaryCoin, [coin1, coin2, coin3]);

const balance = await client.getBalance({
    owner: address,
    coinType: '0x2::sui::SUI',
});

console.log(`Balance: ${Number(balance.totalBalance) / 1e9} SUI`);

const tx = new Transaction();
// Gas coin automatically selected from sender's balance
tx.setGasBudget(10_000_000);

tx.setGasPayment([
    {
        objectId: coinId1,
        version: version1,
        digest: digest1,
    },
    {
        objectId: coinId2,
        version: version2,
        digest: digest2,
    },
]);

use sui::coin::{Self, Coin};
use sui::sui::SUI;

public fun pay_fee(payment: Coin<SUI>) {
    let amount = payment.value();
    assert!(amount >= MINIMUM_FEE, EInsufficientPayment);
    
    // Process payment
    transfer::public_transfer(payment, TREASURY_ADDRESS);
}

use sui::coin::{Self, Coin};
use sui::sui::SUI;

public fun split_payment(
    coin: &mut Coin<SUI>,
    amount: u64,
    ctx: &mut TxContext,
) {
    let split_coin = coin.split(amount, ctx);
    transfer::public_transfer(split_coin, recipient);
}

// Every transaction requires SUI for gas
const tx = new Transaction();
tx.moveCall({
    target: `${packageId}::module::function`,
    arguments: [/* ... */],
});
tx.setGasBudget(10_000_000); // SUI required

public(package) fun request_add_stake(
    pool: &mut StakingPool,
    stake: Balance<SUI>,
    stake_activation_epoch: u64,
    ctx: &mut TxContext,
): StakedSui {
    let sui_amount = stake.value();
    assert!(!pool.is_inactive(), EDelegationToInactivePool);
    assert!(sui_amount > 0, EDelegationOfZeroSui);

    pool.pending_stake = pool.pending_stake + sui_amount;
    StakedSui {
        id: object::new(ctx),
        pool_id: object::id(pool),
        stake_activation_epoch,
        principal: stake,
    }
}

public fun purchase_item(
    payment: Coin<SUI>,
    item_id: ID,
    shop: &mut Shop,
) {
    let item = shop.items.remove(&item_id);
    let price = item.price;
    
    assert!(payment.value() >= price, EInsufficientPayment);
    
    // Handle payment
    transfer::public_transfer(payment, shop.owner);
    transfer::public_transfer(item, tx_context::sender(ctx));
}