Aptos Digital Asset Standard

The Digital Asset (DA) standard is a modern Non-Fungible Token (NFT) standard for Aptos. NFTs represent unique assets on-chain, and are stored in collections. These NFTs can be customized to later be transferred, soulbound, burned, mutated, or customized via your own smart contracts.

This standard replaces the legacy Aptos Token Standard. The most important improvements to note are:

Improvement	Description
Token Extension	Tokens can be easily extended since they are implemented using Move Objects.
Direct NFT Transfer	You can now directly transfer NFTs without the recipient “opting-in” on-chain.
NFT Composability	NFTs can own other NFTs for easy composability.

If you want a simple way to mint NFTs without the ability to customize or extend their functionality, you can use the aptos_token module which implements the DA standard (see the section on how to use it below).

Using the Digital Asset Standard

This standard is implemented with two Objects:

Collections - A set of NFTs with a name and a bit of context for the group.
Tokens - Digital assets which represent unique assets. These are often used to represent NFTs and usually use a uri link to point to more info about the asset (ex. a link to an image, video, etc.).

Digital Asset token and collection relationship

All Tokens are required to have a reference to a parent Collection, but the parent Collection does not own the Token. Newly minted Tokens are usually owned by the creator. From there, they can be transferred to other accounts.

Collections

Field	Description
Description	An optional string smaller than 2048 characters (modifiable with a `MutatorRef`).
Name	A required string to identify the `Collection`. The name must be unique within each account. That means a single creator account cannot create more than one `Collection` with the same name.
Royalty	An optional `Royalty` struct indicating what % of the sale price goes to the creator of the `Collection`. This can be changed with a `MutatorRef` generated by the Royalty module. The Royalty module is an extension for the DA standard. See example usage in `aptos_token.move`.
URI length	An optional string that is smaller than 512 characters which links to relevant content for the `Collection` (modifiable with a `MutatorRef`).

Creating a `Collection`

There are two ways to create a Collection depending on whether you want there to be a maximum supply of Tokens it can hold.

Fixed Maximum Supply

To make a Collection with a fixed supply you can use collection::create_fixed_collection like so:

use aptos_token_objects::collection;
use std::option::{Self, Option};
use aptos_framework::string;

public entry fun create_collection(creator: &signer) {
    let max_supply = 1000;
    let royalty = option::none();

    // Maximum supply cannot be changed after collection creation
    collection::create_fixed_collection(
        creator,
        string::utf8(b"My Collection Description"),
        max_supply,
        string::utf8(b"My Collection"),
        royalty,
        string::utf8(b"https://mycollection.com"),
    );
}

Unlimited Supply

To create a Collection with unlimited supply you can use collection::create_unlimited_collection:

use std::option::{Self, Option};
use aptos_framework::string;

public entry fun create_collection(creator: &signer) {
    let royalty = option::none();

    collection::create_unlimited_collection(
        creator,
        string::utf8(b"My Collection Description"),
        string::utf8(b"My Collection"),
        royalty,
        string::utf8(b"https://mycollection.com"),
    );
}

Customizing a `Collection`

Since each Collection is a Move Object, you can customize it by generating permissions called Refs. Each Ref allows you to modify an aspect of the Object later on. Beyond the normal Object Refs, Collections can also get a MutatorRef by calling get_mutator_ref like so:

use std::option::{Self, Option};
use aptos_framework::string;

public entry fun create_collection(creator: &signer) {
    let royalty = option::none();
    let collection_constructor_ref = &collection::create_unlimited_collection(
        creator,
        string::utf8(b"My Collection Description"),
        string::utf8(b"My Collection"),
        royalty,
        string::utf8(b"https://mycollection.com"),
    );
    let mutator_ref = collection::get_mutator_ref(collection_constructor_ref);
    // Store the mutator ref somewhere safe
}

You can further customize your Collection by adding more resources or functionalities via smart contract. For example, a Collection can track when it was created in order to limit when Tokens can be minted like so:

use std::option::{Self, Option};
use aptos_framework::string;

struct MyCollectionMetadata has key {
    creation_timestamp_secs: u64,
}

public entry fun create_collection(creator: &signer) {
    let royalty = option::none();
    // Constructor ref is a non-storable struct returned when creating a new object.
    // It can generate an object signer to add resources to the collection object.
    let collection_constructor_ref = &collection::create_unlimited_collection(
creator,
        string::utf8(b"My Collection Description"),
        string::utf8(b"My Collection"),
        royalty,
        string::utf8(b"https://mycollection.com"),
    );
    // Constructor ref can be exchanged for signer to add resources to the collection object.
    let collection_signer = &object::generate_signer(collection_constructor_ref);
    move_to(collection_signer, MyCollectionMetadata { creation_timestamp_secs: timestamp::now_seconds() } })
}

Tokens

Field	Description
Description	An optional string smaller than 2048 characters (modifiable with a `MutatorRef`).
Name	A required string to identify the `Collection` that is unique within each `Collection`. This means a single `Collection` account cannot have more than one `Token` with the same name.
Royalty	An optional `Royalty` struct indicating what % of the sale price goes to the creator of the `Collection`. This can be changed with a `MutatorRef` generated by the Royalty module (an extension for the DA standard. See example usage in `aptos_token.move`). Usually royalty is set on collections, but setting it on `Token`s allows the individual `Token` to have a custom royalty amount.
URI length	An optional string that is smaller than 512 characters which links to relevant content for the `Collection` (modifiable with a `MutatorRef`).

Creating Tokens

There are a few ways to create a Token:

Named tokens. These use the name of the Token to generate a named Object. This makes it easy to find the address for the token if you know the token and Collection name, but named Objects are not deletable. Trying to delete the a named token will only delete the data, not the Object itself.

use aptos_token_objects::token;
use std::option::{Self, Option};

public entry fun mint_token(creator: &signer) {
    let royalty = option::none();
    token::create_named_token(
        creator,
        "Collection Name",
        "Description",
        "Token Name",
        royalty,
        "https://mycollection.com/my-named-token.jpeg",
    );
}

“Unnamed” tokens. These create unnamed Objects (which are deletable) but still have a Token name. Because the Object address is not deterministic, you must use an Indexer to find the address for them.

use aptos_token_objects::token;
use std::option::{Self, Option};
use aptos_framework::string;

public entry fun mint_token(creator: &signer) {
    let royalty = option::none();
    token::create(
        creator,
        string::utf8(b"Collection Name"),
        string::utf8(b"Description"),
        string::utf8(b"Token Name"),
        royalty,
        string::utf8(b"https://mycollection.com/my-named-token.jpeg"),
    );
}

Finding Unnamed Token Addresses via Indexer

You can find the addresses of your recently created “unnamed” Tokens by using the Aptos Indexer with queries like the following:

Looking up the collection id by using your account address and the name of the Collection.

Then look up the address (token_data_id) of the Token by using the collection_id (from above) and the name of the token:

Using Tokens

Transfer Tokens

Transferring a Token can be done by calling object::transfer.

public entry fun transfer<T: key>(owner: &signer, object: object::Object<T>, to: address)

Burning Tokens

Burning / deleting a Token requires storing a BurnRef with token::generate_burn_ref, then calling token::burn.

module 0x42::example {
  use std::option;
  use aptos_token_objects::token::{Self, BurnRef, Token};
  use std::string::utf8;
  use aptos_framework::object::{Self, Object};

  struct CustomData has key, drop {
    burn_ref: BurnRef,
  }

  public entry fun mint_token(creator: &signer) {
    let token_constructor_ref = &token::create(
      creator,
      utf8(b"My Collection"),
      utf8(b"My named Token description"),
      utf8(b"My named token"),
      option::none(),
      utf8(b"https://mycollection.com/my-named-token.jpeg"),
    );

    let token_signer = &object::generate_signer(token_constructor_ref);

    let burn_ref = token::generate_burn_ref(token_constructor_ref);

    // Store the burn ref somewhere safe
    move_to(token_signer, CustomData {
      burn_ref,
    });
  }

  public entry fun burn_token(token: Object<Token>) acquires CustomData {
    let token_address = object::object_address(&token);
    // Remove all custom data from the token object.
    // Retrieve the burn ref from storage
    let CustomData { burn_ref } = move_from<CustomData>(token_address);
    // Burn the token
    token::burn(burn_ref);
  }
}

Modifying Tokens After Creation

Mutating a Token’s URI or description requires a MutatorRef (which must be generated when creating the Token, then stored for later).

module 0x42::example {
  use std::option;
  use aptos_token_objects::token::{Self, MutatorRef, Token};
  use std::string::utf8;
  use aptos_framework::object::{Self, Object};

  struct CustomData has key, drop {
    mutator_ref: MutatorRef,
  }

  public entry fun mint_token(creator: &signer) {
    // Constructor ref is a non-storable struct returned when creating a new object.
    // It can be exchanged for signer to add resources to the token object.
    let token_constructor_ref = &token::create(
      creator,
      utf8(b"My Collection"),
      utf8(b"My named Token description"),
      utf8(b"My named Token"),
      option::none(),
      utf8(b"https://mycollection.com/my-named-token.jpeg"),
    );

    let token_signer = &object::generate_signer(token_constructor_ref);

    let mutator_ref = token::generate_mutator_ref(token_constructor_ref);

    // Store the mutator ref somewhere safe
    move_to(token_signer, CustomData {
      mutator_ref,
    });
  }

  public entry fun mutate_token(token: Object<Token>) acquires CustomData {
    let token_address = object::object_address(&token);
    // Retrieve the mutator ref from storage
    let CustomData { mutator_ref } = move_from<CustomData>(token_address);
    // Change token description
    token::set_description(&mutator_ref, utf8(b"This is my named Token description"));
  }
}

Extending Tokens

Tokens can be extended either by adding additional resources (since they are an Object) or using Refs to modify the Object.

Aptos Token

For NFT creators who want to avoid writing their own logic for how your NFT should work, you can use the aptos_token module to mint an NFT. This module is already deployed at 0x4 and allows you to:

Mint a Token you can transfer with royalties.
Mint a soulbound Token.
Manage the resources your NFT has.

See the aptos_token reference docs for all the helper functions you can use.

Minting with `aptos_token`

Minting a Token using aptos_token requires the same parameters as any token that implements the DA standard. In addition though, the aptos_token module allows you to specify a property map of key/value pairs for any other properties your specific NFT may require.

You can mint your Token by calling aptos_token::mint like so:

public entry fun mint(
    creator: &signer,
    collection: String,
    description: String,
    name: String,
    uri: String,
    property_keys: vector<String>,
    property_types: vector<String>,
    property_values: vector<vector<u8>>,
) acquires AptosCollection, AptosToken

Soulbound Tokens

To mint a soul bound Token, you can call aptos_token::mint_soul_bound instead:

public entry fun mint_soul_bound(
    creator: &signer,
    collection: String,
    description: String,
    name: String,
    uri: String,
    property_keys: vector<String>,
    property_types: vector<String>,
    property_values: vector<vector<u8>>,
    soul_bound_to: address,
) acquires AptosCollection