Coin Example

module examples::my_coin {
    use sui::coin::{Self, TreasuryCap};

    /// The One-Time-Witness for the coin
    public struct MY_COIN has drop {}

    /// Module initializer - creates currency
    fun init(witness: MY_COIN, ctx: &mut TxContext) {
        let (treasury, metadata) = coin::create_currency(
            witness,
            6,              // decimals
            b"MY_COIN",     // symbol
            b"",            // name
            b"",            // description
            option::none(), // icon_url
            ctx,
        );
        
        // Freeze metadata to make it immutable
        transfer::public_freeze_object(metadata);
        
        // Transfer treasury capability to publisher
        transfer::public_transfer(treasury, ctx.sender())
    }

    /// Mint new coins using the TreasuryCap
    public fun mint(
        treasury_cap: &mut TreasuryCap<MY_COIN>,
        amount: u64,
        recipient: address,
        ctx: &mut TxContext,
    ) {
        let coin = coin::mint(treasury_cap, amount, ctx);
        transfer::public_transfer(coin, recipient)
    }
}

public struct MY_COIN has drop {}

public fun mint(
    treasury_cap: &mut TreasuryCap<MY_COIN>,
    amount: u64,
    recipient: address,
    ctx: &mut TxContext,
) {
    let coin = coin::mint(treasury_cap, amount, ctx);
    transfer::public_transfer(coin, recipient)
}

module examples::fixed_supply {
    use sui::coin;
    use sui::balance::{Self, Supply};

    public struct FIXED_SUPPLY has drop {}

    public struct Treasury has key {
        id: UID,
        supply: Supply<FIXED_SUPPLY>,
        max_supply: u64,
    }

    const MAX_SUPPLY: u64 = 1_000_000_000; // 1 billion
    const EMaxSupplyReached: u64 = 0;

    fun init(witness: FIXED_SUPPLY, ctx: &mut TxContext) {
        let (mut treasury_cap, metadata) = coin::create_currency(
            witness,
            6,
            b"FIXED",
            b"Fixed Supply Coin",
            b"A coin with fixed maximum supply",
            option::none(),
            ctx,
        );

        // Mint entire supply
        let supply = treasury_cap.treasury_into_supply();

        transfer::public_freeze_object(metadata);
        transfer::share_object(Treasury {
            id: object::new(ctx),
            supply,
            max_supply: MAX_SUPPLY,
        });
    }

    public fun mint(
        treasury: &mut Treasury,
        amount: u64,
        ctx: &mut TxContext,
    ): Coin<FIXED_SUPPLY> {
        let current_supply = balance::supply_value(&treasury.supply);
        assert!(
            current_supply + amount <= treasury.max_supply,
            EMaxSupplyReached
        );

        coin::from_balance(
            balance::increase_supply(&mut treasury.supply, amount),
            ctx
        )
    }
}

module examples::regcoin {
    use sui::coin;
    use sui::deny_list::{DenyList};

    public struct REGCOIN has drop {}

    fun init(witness: REGCOIN, ctx: &mut TxContext) {
        let (treasury, deny_cap, metadata) = 
            coin::create_regulated_currency(
                witness,
                6,
                b"REG",
                b"Regulated Coin",
                b"A regulated coin with deny list",
                option::none(),
                ctx,
            );

        transfer::public_freeze_object(metadata);
        transfer::public_transfer(treasury, ctx.sender());
        transfer::public_transfer(deny_cap, ctx.sender());
    }
}

sui client transfer-sui \
  --to 0xRECIPIENT \
  --sui-coin-object-id 0xCOIN_ID \
  --amount 1000 \
  --gas-budget 1000000

sui client balance 0xADDRESS

transfer::public_freeze_object(metadata);

transfer::public_transfer(treasury, trusted_admin);

assert!(total_supply + amount <= MAX_SUPPLY, EMaxSupply);

6  // Standard for most coins (like USDC)
9  // For high-precision tokens
0  // For NFT-like tokens