Creating a NFT Contract

In this tutorial, you will create a non-fungible token (NFT) using the NEAR SDK Contract Tools package. This package is a collection of common tools and patterns to simplify smart contract development, including:

Storage fee management
Escrow pattern and derive macro
Owner pattern and derive macro
Pause pattern and derive macro
Role-based access control
Derive macros for NEP standards
- NEP-141 (fungible token), extension NEP-148
- NEP-145 (storage management), and integrations for the fungible token and non-fungible token standards
- NEP-171 (non-fungible token), extensions NEP-177, NEP-178, NEP-181
- NEP-297 (events)

Introduction

Use the existing global NFT contract by default. Use this guide only if your application truly requires behavior the global contract does not provide. Use near-contract-standards or near-sdk-contract-tools for the token implementation; do not implement the NFT standard by hand. near-sdk-contract-tools allows you to implement the minting/burning logic, access control, and other NFT standards by simply deriving macros on the contract’s struct, as OpenZeppelin does for Ethereum contracts.

Basic NFT Methods

To derive basic NFT methods to your smart contract, you need to derive the NonFungibleToken macro to the contract’s struct:

lib.rs

#[derive(PanicOnDefault, Owner, NonFungibleToken)]
#[non_fungible_token(transfer_hook = "TransferHook")]
#[near(contract_state)]
pub struct MyNftContract {}

See code on GitHub

This will bring all the basic NFT methods to the contract:

new
contract_source_metadata
nft_is_approved
nft_metadata
nft_supply_for_owner
nft_token
nft_tokens
nft_tokens_for_owner
nft_total_supply
nft_approve
nft_resolve_transfer
nft_revoke
nft_revoke_all
nft_transfer
nft_transfer_call
storage_balance_bounds
storage_balance_of
storage_deposit
storage_unregister
storage_withdraw

To bring basic owner methods to the contract, you also need to derive the Owner macro, which adds the following methods:

own_get_owner
own_get_proposed_owner
own_accept_owner
own_propose_owner
own_renounce_owner

Initialization

To initialize the basic NFT contract with a custom owner, metadata, and storage bounds, implement the new method:

lib.rs

#[near]
impl MyNftContract {
    #[init]
    pub fn new(owner_id: AccountId, metadata: ContractMetadata) -> Self {
        let mut contract = Self {};

        Owner::init(&mut contract, &owner_id);

        contract.set_contract_metadata(&metadata);

        contract.set_storage_balance_bounds(&StorageBalanceBounds {
            min: NearToken::from_yoctonear(7000000000000000000000),
            max: Some(NearToken::from_yoctonear(21000000000000000000000)),
        });

        contract
    }
}

See code on GitHub

Transfer Hook

Use a transfer hook to run application logic before or after the library-provided transfer. Keep the standard nft_transfer implementation in the library:

transfer_hook.rs

pub struct TransferHook;

impl Hook<MyNftContract, Nep171Transfer<'_>> for TransferHook {
    fn hook<R>(
        contract: &mut MyNftContract,
        transfer: &Nep171Transfer<'_>,
        f: impl FnOnce(&mut MyNftContract) -> R,
    ) -> R {
        // Log, check preconditions, save state, etc.
        log!(
            "NEP-171 transfer from {} to {} of {} tokens",
            transfer.sender_id,
            transfer.receiver_id,
            transfer.token_id
        );

        let storage_usage_before = env::storage_usage();

        let r = f(contract); // execute wrapped function

        let storage_usage_after = env::storage_usage();
        log!(
            "Storage delta: {}",
            storage_usage_after - storage_usage_before
        );

        r
    }
}

See code on GitHub

Then derive it to our contract struct:

lib.rs

#[derive(PanicOnDefault, Owner, NonFungibleToken)]
#[non_fungible_token(transfer_hook = "TransferHook")]
#[near(contract_state)]
pub struct MyNftContract {}

See code on GitHub

Minting

By default, the NFT standards do not include a minting method. However, you can easily mint tokens for the owner by implementing an nft_mint method:

mint.rs

#[payable]
pub fn nft_mint(
    &mut self,
    token_id: TokenId,
    metadata: TokenMetadata,
    owner_id: Option<AccountId>,
) {
    // Check account's storage balance and deposit if necessary
    let storage_balance_bounds = self.storage_balance_bounds();
    log!("Storage balance bounds: {:?}", storage_balance_bounds);

    let storage_balance = self
        .storage_balance_of(owner_id.clone().unwrap_or(env::predecessor_account_id()))
        .unwrap_or_default();
    log!("Storage balance: {:?}", storage_balance);
    if storage_balance.total < storage_balance_bounds.min {
        // Deposit storage if necessary
        self.storage_deposit(
            Some(owner_id.clone().unwrap_or(env::predecessor_account_id())),
            None,
        );
    }

    Nep177Controller::mint_with_metadata(
        self,
        &token_id,
        &owner_id.unwrap_or(env::predecessor_account_id()),
        &metadata,
    )
    .unwrap_or_else(|e| env::panic_str(&e.to_string()));
}

See code on GitHub

You can modify this method as you need, for example, to allow minting only when the contract is not paused (requires deriving Pausable hook), or to enable minting only to specific accounts with a certain role or from a whitelist with custom limitations.

Burning

In the same way that minting is not included in the NFT standards, burning is also not included. However, you can also easily implement it. To allow users to burn their tokens, you can add a burn method:

burn.rs

#[near]
impl MyNftContract {
    #[payable]
    pub fn nft_burn(&mut self, token_id: TokenId) {
        assert_one_yocto();

        Nep177Controller::burn_with_metadata(self, &token_id, &env::predecessor_account_id())
            .unwrap_or_else(|e| env::panic_str(&e.to_string()));
    }
}

See code on GitHub

Conclusion

Using near-sdk-contract-tools is a simple and flexible way to create an NFT contract with minimal boilerplate, which allows you to focus on the business logic. You can further extend this contract with more features like pausing, role-based access control, escrow pattern, and more by deriving corresponding macros from the package.

Fungible Tokens (FT)

Non-Fungible Tokens (NFT)

Linkdrops

Governance

DeFi

Off-chain Compute

Identity

Social

Lockup Contracts

Liquid Staking

Creating a NFT Contract

Introduction

Basic NFT Methods

Initialization

Transfer Hook

Minting

Burning

Conclusion

​Introduction

​Basic NFT Methods

​Initialization

​Transfer Hook

​Minting

​Burning

​Conclusion

Introduction

Basic NFT Methods

Initialization

Transfer Hook

Minting

Burning

Conclusion