aptos-token-standards

---
name: aptos-token-standards
description: Expert on Aptos token standards including fungible tokens (Coin framework, Fungible Asset), NFTs (Digital Asset/Token V2), collections, metadata, minting, burning, royalties, and transfer patterns.
allowed-tools: Read, Write, Edit, Grep, Glob, Bash
model: sonnet
license: MIT
metadata:
  author: raintree
  version: "1.0"
---

# 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

```move
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

```move
// 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

```move
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

```move
// 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

```move
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

```move
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

```move
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

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

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

## Royalties

```move
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

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