Fungible tokens

module coin::coin;

use sui::coin::{Self, TreasuryCap};
use sui::url;

public struct COIN has drop {}

fun init(witness: COIN, ctx: &mut TxContext) {
		let (treasury, metadata) = coin::create_currency(
				witness,
				6,
				b"BMEME",
				b"Best Meme",
				b"This is the best meme coin ever!",
				option::some(url::new_unsafe_from_bytes(b"https://www.pexels.com/photo/close-up-photo-of-dog-wearing-sunglasses-1629781/")),
				ctx,
		);
		transfer::public_freeze_object(metadata);
		transfer::public_transfer(treasury, ctx.sender())
}

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

/// The OTW for the Token / Coin.
public struct LOYALTY has drop {}

/// This is the Rule requirement for the `GiftShop`.
public struct GiftShop has drop {}

public struct Gift has key, store {
    id: UID,
}

// Create a new LOYALTY currency, create a `TokenPolicy` for it.
fun init(otw: LOYALTY, ctx: &mut TxContext) {
    let (treasury_cap, coin_metadata) = coin::create_currency(
        otw,
        0, // no decimals
        b"LOY", // symbol
        b"Loyalty Token", // name
        b"Token for Loyalty", // description
        option::none(), // url
        ctx,
    );

    let (mut policy, policy_cap) = token::new_policy(&treasury_cap, ctx);

    // Enforce that the token can only be used spent at this shop
    token::add_rule_for_action<LOYALTY, GiftShop>(
        &mut policy,
        &policy_cap,
        token::spend_action(),
        ctx,
    );

    token::share_policy(policy);

    transfer::public_freeze_object(coin_metadata);
    transfer::public_transfer(policy_cap, tx_context::sender(ctx));
    transfer::public_transfer(treasury_cap, tx_context::sender(ctx));
}

... // more module code

/// Buy a gift for 10 tokens. The `Gift` is received, and the `Token` is
/// spent (stored in the `ActionRequest`'s `burned_balance` field).
public fun buy_a_gift(token: Token<LOYALTY>, ctx: &mut TxContext): (Gift, ActionRequest<LOYALTY>) {
    assert!(token::value(&token) == GIFT_PRICE, EIncorrectAmount);

    let gift = Gift { id: object::new(ctx) };
    let mut req = token::spend(token, ctx);

    // only required because we've set this rule
    token::add_approval(GiftShop {}, &mut req, ctx);

    (gift, req)
}

module usdc_usage::example;

use sui::coin::Coin;
use sui::sui::SUI;
use usdc::usdc::USDC;

public struct Sword has key, store {
  id: UID,
  strength: u64
}

public fun buy_sword_with_usdc(
  coin: Coin<USDC>,
  tx_context: &mut TxContext
): Sword {
  // We're creating a sword that's as strong as the amount of money the user
  //  spends. Since USDC has six decimal places, a $1 USDC sword would
  //  have a strength of 1,000,000!
  //  See: https://docs.sui.io/references/framework/sui/coin#sui_coin_value
  let sword = create_sword(coin.value(), tx_context);

  // After making the sword, we transfer the sender's USDC to oursleves
  // See: https://docs.sui.io/references/framework/sui/transfer#sui_transfer_public_transfer
  transfer::public_transfer(coin, @0xYOUR_TREASURY_ADDRESS);

  // At some point we need to transfer the sword to the sender or they'll
  //  be very unhappy. Here, we assume that another function calls this
  //  one and handles the transfer step.
  sword
}

fun create_sword(strength: u64, tx_context: &mut TxContext): Sword {
  let id = object::new(tx_context);
  Sword { id, strength }
}

... // more module code below