Skeleton and Rust Architecture

In this article, you’ll learn about the basic architecture behind the NFT contract that you’ll develop while following this “Zero to Hero” series.

You’ll discover the contract’s layout and you’ll see how the Rust files are structured in order to build a feature-complete smart contract.

Introduction

This tutorial presents the code skeleton for the NFT smart contract and its file structure.

Once every file and functions have been covered, we will guide you through the process of building the mock-up contract to confirm that your Rust setup works.

File structure

Following a regular Rust project, the file structure for this smart contract has:

nft-contract
├── Cargo.lock
├── Cargo.toml
├── README.md
└── src
    ├── approval.rs
    ├── enumeration.rs
    ├── lib.rs
    ├── metadata.rs
    ├── mint.rs
    ├── nft_core.rs
    ├── events.rs
    └── royalty.rs

• The file Cargo.toml defines the code dependencies
• The src folder contains all the Rust source files

Source files

Here is a brief description of what each source file is responsible for:

approval.rs

This allows people to approve other accounts to transfer NFTs on their behalf.

This file contains the logic that complies with the standard’s approvals management extension. Here is a breakdown of the methods and their functions:

You’ll learn more about these functions in the approvals section of the Zero to Hero series.

enumeration.rs

This file provides the functions needed to view information about NFTs, and follows the standard’s enumeration extension.

You’ll learn more about these functions in the enumeration section of the tutorial series.

lib.rs

This file outlines what information the contract stores and keeps track of.

You’ll learn more about these functions in the minting section of the tutorial series.

metadata.rs

This file is used to keep track of the information to be stored for tokens, and metadata.
In addition, you can define a function to view the contract’s metadata which is part of the standard’s metadata extension.

You’ll learn more about these functions in the minting section of the tutorial series.

mint.rs

Contains the logic to mint the non-fungible tokens

nft_core.rs

Core logic that allows to transfer NFTs between users.

You’ll learn more about these functions in the core section of the tutorial series.

royalty.rs

Contains payout-related functions.

You’ll learn more about these functions in the royalty section of the tutorial series.

events.rs

Contains events-related structures.

You’ll learn more about these functions in the events section of the tutorial series.

Building the skeleton

If you haven’t cloned the main repository yet, open a terminal and run:

git clone https://github.com/near-examples/nft-tutorial/

Next, go to the nft-contract-skeleton/ folder and build the contract with cargo-near:

cd nft-tutorial
cd nft-contract-skeleton/
cargo near build

Since this source is just a skeleton you’ll get many warnings about unused code, such as:

   Compiling nft_contract_skeleton v0.1.0 (/Users/near-examples/Documents/my/projects/near/examples/nft-tutorial/nft-contract-basic)
 │ warning: unused imports: `LazyOption`, `LookupMap`, `UnorderedMap`, `UnorderedSet`
 │  --> src/lib.rs:3:29
 │   |
 │ 3 | use near_sdk::collections::{LazyOption, LookupMap, UnorderedMap, UnorderedSet};
 │   |                             ^^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^^^^  ^^^^^^^^^^^^
 │   |
 │   = note: `#[warn(unused_imports)]` on by default
 │
 │ warning: unused import: `Base64VecU8`
 │  --> src/lib.rs:4:28
 │   |
 │ 4 | use near_sdk::json_types::{Base64VecU8, U128};
 │   |

 │ warning: `nft_contract_skeleton` (lib) generated 48 warnings (run `cargo fix --lib -p nft_contract_skeleton` to apply 45 suggestions)
 │     Finished release [optimized] target(s) in 11.01s
 ✓ Contract successfully built!

Don’t worry about these warnings, you’re not going to deploy this contract yet.
Building the skeleton is useful to validate that your Rust toolchain works properly and that you’ll be able to compile improved versions of this NFT contract in the upcoming tutorials.

Conclusion

You’ve seen the layout of this NFT smart contract, and how all the functions are laid out across the different source files.
Using yarn, you’ve been able to compile the contract, and you’ll start fleshing out this skeleton in the next Minting tutorial.