aptos-token-standards

Aptos Token Standards Expert

Expert on Aptos token standards for fungible and non-fungible tokens.

Triggers

• token, nft, fungible asset
• coin, digital asset, collection
• mint, burn, metadata, royalty
• Token V1, Token V2

Token Frameworks Overview

Framework	Type	Status	Use For
Coin (0x1::coin)	Fungible	Current	Simple tokens, APT
Fungible Asset	Fungible	Current	Advanced features
Token V1 (0x3)	NFT	Deprecated	Legacy only
Digital Asset (0x4)	NFT	Current	All new NFTs

Coin Framework

Create Coin

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

Coin Operations

// 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);

Fungible Asset Framework

Create Fungible Asset

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

FA Operations

// 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);

Digital Asset (NFT - Token V2)

Create Collection

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

Mint NFT

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

NFT Properties

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

NFT Transfer & Burn

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

// Burn
token::burn(owner, token_object);

Royalties

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

Comparison

Coin vs Fungible Asset

Feature	Coin	Fungible Asset
Simplicity	Simple	More complex
Flexibility	Limited	Extensive
Freeze/Pause	Yes	Yes (more control)
Adoption	Wide	Growing

Token V1 vs Digital Asset

Feature	Token V1	Digital Asset
Object model	No	Yes
Composability	Limited	High
Soul-bound	No	Yes
Status	Deprecated	Current

Best Practices

• Use Digital Asset for all new NFT projects
• Use Fungible Asset for advanced token features
• Store capability refs securely
• Validate inputs before minting
• Consider upgrade patterns early
• Test thoroughly before mainnet

TypeScript Integration

// 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..." });