module my_addr::my_coin {
    use aptos_framework::coin;
    
    struct MyCoin {}
    
    struct Caps has key {
        mint_cap: coin::MintCapability<MyCoin>,
        burn_cap: coin::BurnCapability<MyCoin>,
    }
    
    fun init_module(sender: &signer) {
        let (burn_cap, freeze_cap, mint_cap) = coin::initialize<MyCoin>(
            sender,
            string::utf8(b"My Coin"),
            string::utf8(b"MYC"),
            8,    // decimals
            true, // monitor_supply
        );
        move_to(sender, Caps { mint_cap, burn_cap });
    }
}

// Mint
let coins = coin::mint(amount, &caps.mint_cap);
coin::deposit(recipient, coins);
 
// Burn
let coins = coin::withdraw<MyCoin>(account, amount);
coin::burn(coins, &caps.burn_cap);
 
// Transfer
coin::transfer<MyCoin>(from, to, amount);
 
// Balance
coin::balance<MyCoin>(account);
 
// Register to receive
coin::register<MyCoin>(account);

use aptos_framework::fungible_asset::{Self, MintRef, BurnRef, TransferRef};
use aptos_framework::primary_fungible_store;
 
struct Refs has key {
    mint_ref: MintRef,
    burn_ref: BurnRef,
    transfer_ref: TransferRef,
}
 
fun init_module(admin: &signer) {
    let constructor_ref = &object::create_named_object(admin, b"MY_FA");
    
    primary_fungible_store::create_primary_store_enabled_fungible_asset(
        constructor_ref,
        option::none(),  // max_supply
        string::utf8(b"My FA"),
        string::utf8(b"MFA"),
        8,
        string::utf8(b"https://icon.png"),
        string::utf8(b"https://project.com"),
    );
    
    move_to(admin, Refs {
        mint_ref: fungible_asset::generate_mint_ref(constructor_ref),
        burn_ref: fungible_asset::generate_burn_ref(constructor_ref),
        transfer_ref: fungible_asset::generate_transfer_ref(constructor_ref),
    });
}

// Mint
let fa = fungible_asset::mint(&refs.mint_ref, amount);
primary_fungible_store::deposit(recipient, fa);
 
// Burn
let fa = primary_fungible_store::withdraw(holder, amount);
fungible_asset::burn(&refs.burn_ref, fa);
 
// Freeze
fungible_asset::set_frozen_flag(&refs.transfer_ref, account, true);

use aptos_token_objects::collection;
 
collection::create_unlimited_collection(
    creator,
    string::utf8(b"Description"),
    string::utf8(b"Collection Name"),
    option::none(),  // royalty
    string::utf8(b"https://collection.uri"),
);
 
// Or fixed supply
collection::create_fixed_collection(creator, description, max_supply, name, royalty, uri);

use aptos_token_objects::token;
 
let constructor_ref = token::create_named_token(
    creator,
    collection_name,
    string::utf8(b"Description"),
    token_name,
    option::none(),  // royalty
    string::utf8(b"https://token.uri"),
);
 
// Transfer to recipient
let transfer_ref = object::generate_transfer_ref(&constructor_ref);
let linear_ref = object::generate_linear_transfer_ref(&transfer_ref);
object::transfer_with_ref(linear_ref, recipient);

use aptos_token_objects::property_map;
 
let mutator_ref = property_map::generate_mutator_ref(&constructor_ref);
 
property_map::add_typed(&mutator_ref, string::utf8(b"level"), 1u64);
property_map::add_typed(&mutator_ref, string::utf8(b"rarity"), string::utf8(b"legendary"));
 
// Update later
property_map::update_typed(&mutator_ref, &string::utf8(b"level"), 2u64);

// Transfer
object::transfer(owner, token_object, recipient);
 
// Burn
token::burn(owner, token_object);

use aptos_token_objects::royalty;
 
let royalty = royalty::create(
    5,    // numerator (5%)
    100,  // denominator
    payee_address
);
 
collection::create_unlimited_collection(
    creator, description, name,
    option::some(royalty),  // royalty
    uri
);

// Coin balance
const balance = await aptos.getAccountCoinAmount({
  accountAddress: "0x...",
  coinType: "0x1::aptos_coin::AptosCoin"
});
// NFTs
const tokens = await aptos.getAccountOwnedTokens({ accountAddress: "0x..." });
// Token data
const data = await aptos.getDigitalAssetData({ digitalAssetAddress: "0x..." });