How to deploy an NFT token

Developer Guide Masternode and DEX APIs FAQ
Search…
Create a unique ERC721-equivalent token (ie: CryptoKitties) on TomoChain!
This article will explain:
What is a Non-Fungible Token (NFT)
Use-cases of NFT
How-to step-by-step deploy a NFT token on TomoChain
What is a Non-Fungible Token (NFT)?
Fungible tokens are all equal and interchangeable. For instance, dollars or Bitcoins or 1 kilogram of pure gold or ERC20 tokens. All TOMO are equivalent too, they are the same and have the same value. They are interchangeable 1:1. This is a fungible token.
Non-fungible tokens (NFTs) are all distinct and special. Every token is rare, with unique atributes and different value. For instance: CryptoKitty tokens, collectible cards, airplane tickets or real art paintings. Every item has its own characteristics and specifics and is clearly differentiable to another one. They are not interchangeable 1:1. They are distinguishable.
Think of Non-Fungible Tokens (NFT) as a rare collectible on the TomoChain network. Every token has unique characteristics, its own metadata and special attributes
Non-Fungible Tokens (NFT) are used to create verifiable digital scarcity. NFTs are unique and distinctive tokens that you can mainly find on EVM blockchains.
The ERC-721 is the standard interface for Non-Fungible Tokens (but there are also other NFTs, like ERC1155). ERC721 is a set of rules to make your NFT easy for other people / apps / contracts to interface with.
ERC721 is a free, open standard that describes how to build non-fungible or unique tokens on EVM compatible blockchains. While most tokens are fungible (not distinguishable), ERC721 tokens are all unique, with individual identities and properties. Think of them like rare, one-of-a-kind collectables — each unit is a unique item with its own serial number.
ERC20: identical tokens. ERC721: unique tokens
Some high demand non-fungible tokens are applications like CryptoKitties, Decentraland, CryptoPunks, and many others.
CryptoKitties
At the end of 2017, NFTs made a remarkable entrance in the blockchain world with the success of CryptoKitties. Each one is a unique collectible item, with its own serial number, which can be compared to its DNA card. This unleashed an unprecedented interest for NFTs, that went so far as to clog the Ethereum network. The CryptoKitties market alone generated $12 million dollars in two weeks after its launch, and over $25 million in total. Some rare cryptokitties were even sold for 600 ETH ($170,000).
The strength of NFTs resides in the fact that each token is unique and cannot be mistaken for another one– unlike bitcoins, for example, which are interchangeable with one another.
Crypto Item Standard (ERC-1155)
One step further in the non-fungible token space is the ERC-1155 Standard proposed by the Enjin team, also known as the “Crypto Item Standard”. This is an improved version of ERC-721 which will actually be suitable for platforms where there are tens of thousands of digital items and goods.
Online games can have up to 100,000 different digital items. The current problem with ERC-721 is that if we would like to tokenize all those 100,000 items, then we would need to deploy 100,000 separate smart contracts.
​ERC-1155 standard combines ERC-20 and ERC-721 tokens in its smart contract. Each token is saved in the contract with a minimal set of data that distinguishes it from others. This allows for the creation of bigger collections which contain multiple different items.
Use-cases of Non-Fungible Tokens (NFT)
Most of the time when people think about ERC-721 or NFT, they refer to the most notably successful CryptoKitties. But there are many other usability applications for NFT contracts:
Software titles or software licences to guarantee anti-piracy, privacy and transferability — like Collabs.io​
Betting in real time on the outcome of a video game being live-streamed
Gaming in general is an important field of experimentation and development for the uses of NFT in the future. 
Concert tickets and sports match tickets can be tokenized and name-bound, preventing fraud and at the same time offering fans an option to have a single place where to collect all their past event experiences
Digital Art (or physical art!) has already entered the game and showed an important usage of ERC721. Digital art auctions were the first application and still are the first thought of non-fungible token standards. The auctions organized by Christie’s revealed the appeal of the public for crypto-collectibles. Several digital art assets were sold during this event, the high point being the sale of the ‘Celestial Cyber Dimension’, an ERC721 CryptoKitty piece of art, for $140,000​
Real Estate assets, to carry out transfers of houses, land and other ‘tokenized’ properties through smart contracts
Financial instruments like loans, burdens and other responsibilities, or a futures contract to buy 1,000 barrels of oil for $60k on May 1
KYC compliance check to verify users. Receiving a specific NFT token in your wallet similar to the blue checkmark ☑️ on Twitter — like Wyre​
and more…
​Crypto-Collectibles are more than a passing craze. It is easy to see the reason why, especially when you look at the potential of the crypto-collectible technology, including: securing digital ownership, protecting intellectual property, tracking digital assets and overall creating real world value.
How to deploy a NFT token on TomoChain
This article will create a basic ERC721 token using the OpenZeppelin implementation of the ERC721 standard. Look at the links in order to familiarize yourself with the requirements as they can sometimes be hidden in the excellent OpenZeppelin ERC721 implementations.
The assets that your ERC721 tokens (NFT) represent will influence some of the design choices for how your contract works, most notably how new tokens are created.
You can have an initial supply of tokens defined during token creation
You can have a function, which is only callable by the contract creator (or others — if you allow this) that will issue new tokens when called
For example, in CryptoKitties, players are able to “breed” their Kitties, which creates new Kitties (tokens). However, if your ERC721 token represents something more tangible, like concert tickets, you may not want token holders to be able to create more tokens. In some cases, you may even want token holders to be able to “burn” their tokens, effectively destroying them.
Let’s Start the NFT Tutorial
We will now implement an NFT collectible token, like CryptoKitties but with simpler logic.
You’ll learn how to create non fungible tokens, how to write tests for your smart contracts and how to interact with them once deployed.
We’ll build non-fungible collectibles: gradient tokens. Every token will be represented as a unique CSS gradient and will look somewhat like this:
​
0. Prerequisites
The first prerequisites you should have:
Install Node.js & npm (“Node.js Package Manager”)
Install Truffle
1
npm install -g truffle
Copied!
1. Creating a new project
Create a new directory and move inside it. Then start a new Truffleproject:
1
mkdir nft-tutorial 
2
cd nft-tutorial
3
truffle init
Copied!
We will use OpenZeppelin ERC721 implementation, which is quick and easy and broadly used. Install OpenZeppelin in the current folder.
1
npm install openzeppelin-solidity
Copied!
2. Preparing your TOMO wallet
​Create a TOMO wallet. Then grab a few tokens:
TomoChain (testnet): Get free tokens from faucet (grab ~60 TOMO)
TomoChain (mainnet): You will need real TOMO from exchanges
Go to Settings menu, select Backup wallet and then Continue. Here you can see your wallet’s private key and the 12-word recovery phrase.
Write down your 12-word recovery phrase.
3. Writing the Smart Contract
3.1 GradientToken.sol
We’ll be extending the OpenZeppelin ERC721 token contracts to create our Gradient Token.
1.Go to contracts/ folder and create a new file called GradientToken.sol
2.Copy the following code
1
pragma solidity ^0.5.4;import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol';
2
import 'openzeppelin-solidity/contracts/ownership/Ownable.sol';// NFT Gradient token
3
// Stores two values for every token: outer color and inner colorcontract GradientToken is ERC721Full, Ownable {
4
  
5
  using Counters for Counters.Counter;
6
  Counters.Counter private tokenId;
7
 
8
  struct Gradient {
9
    string outer;
10
    string inner;
11
  }
12
  
13
  Gradient[] public gradients;  constructor(
14
    string memory name,
15
    string memory symbol
16
  )
17
    ERC721Full(name, symbol)
18
    public
19
  {}
20
 
21
 
22
  // Returns the outer and inner colors of a token 
23
  function getGradient( uint256 gradientTokenId ) public view returns(string memory outer, string memory inner){
24
    Gradient memory _gradient = gradients[gradientTokenId];    outer = _gradient.outer;
25
    inner = _gradient.inner;
26
  }  // Create a new Gradient token with params: outer and inner
27
  function mint(string memory _outer, string memory _inner) public payable onlyOwner {
28
    uint256 gradientTokenId = tokenId.current();
29
    
30
    Gradient memory _gradient = Gradient({ outer: _outer, inner: _inner });
31
    gradients.push(_gradient);
32
   _mint(msg.sender, gradientTokenId);
33
    tokenId.increment();
34
  }
35
 
36
}
Copied!
We inherited from two contracts: ERC721Full to make it represent a non-fungible token, and from the Ownable contract.
Every token will have a unique tokenId, like a serial number. We also added two attributes: inner and outer to save CSS colors.
Ownable allows managing authorization. It assigns ownership to the deployer (when the contract is deployed) and adds modifier onlyOwner that allows restrictions to certain methods only to the contract owner. Also, ownership can be transferred. Additionally, third parties can be approved to spend tokens, burn tokens, etc.
Our solidity code is simple and I would recommend a deeper dive into the ERC-721 standard and the OpenZeppelin implementation.
You can see the functions to use in OpenZeppelin ERC721 here and here.
You can find another ERC721 smart contract example by OpenZeppelin here.
4. Config Migrations
4.1 Create the migration scripts
In the migrations/ directory, create a new file called 2_deploy_contracts.js and copy the following:
1
const GradientToken = artifacts.require("GradientToken");module.exports = function(deployer) {
2
 
3
  const _name = "Gradient Token";
4
  const _symbol = "GRAD";
5
  
6
  return deployer
7
    .then(() => deployer.deploy(GradientToken, _name, _symbol));
8
};
Copied!
This code will deploy or migrate our contract to TomoChain, with the name Gradient Token and the symbol GRAD.
4.2 Configure truffle.js
Now we set up the migrations: the blockchain where we want to deploy our smart contract, specify the wallet address to deploy, gas, price, etc.
1. Install Truffle’s HDWalletProvider, a separate npm package to find and sign transactions for addresses derived from a 12-word mnemonic.
1
npm install truffle-hdwallet-provider
Copied!
2. Open truffle.js file (truffle-config.js on Windows). Here the migration settings can be edited: networks, chain IDs, gas... You have multiple networks to migrate your ICO, you can deploy: locally, ganache, public Ropsten (ETH) testnet, TomoChain (testnet), TomoChain (Mainnet), etc…
Both Testnet and Mainnet network configurations are described in the official TomoChain documentation — Networks. We need the RPC endpoint, the Chain id and the HD derivation path.
Replace the truffle.js file with this new content:
1
const HDWalletProvider = require('truffle-hdwallet-provider');
2
const infuraKey = "a93ffc...<PUT YOUR INFURA-KEY HERE>";// const fs = require('fs');
3
// const mnemonic = fs.readFileSync(".secret").toString().trim();
4
const mnemonic = '<PUT YOUR WALLET 12-WORD RECOVERY PHRASE HERE>';module.exports = {  networks: {
5
    // Useful for testing. The `development` name is special - truffle uses it by default
6
    development: {
7
      host: "127.0.0.1",     // Localhost (default: none)
8
      port: 8545,            // Standard Ethereum port (default: none)
9
      network_id: "*",       // Any network (default: none)
10
    },    // Useful for deploying to a public network.
11
    // NB: It's important to wrap the provider as a function.
12
    ropsten: {
13
      //provider: () => new HDWalletProvider(mnemonic, `https://ropsten.infura.io/${infuraKey}`),
14
      provider: () => new HDWalletProvider(
15
        mnemonic,
16
        `https://ropsten.infura.io/${infuraKey}`,
17
        0,
18
        1,
19
        true,
20
        "m/44'/889'/0'/0/", // Connect with HDPath same as TOMO
21
      ),
22
      network_id: 3,       // Ropsten's id
23
      gas: 5500000,        // Ropsten has a lower block limit than mainnet
24
      // confirmations: 2,    // # of confs to wait between deployments. (default: 0)
25
      // timeoutBlocks: 200,  // # of blocks before a deployment times out  (minimum/default: 50)
26
      // skipDryRun: true     // Skip dry run before migrations? (default: false for public nets )
27
    },    // Useful for deploying to TomoChain testnet
28
    tomotestnet: {
29
      provider: () => new HDWalletProvider(
30
        mnemonic,
31
        "https://testnet.tomochain.com",
32
        0,
33
        1,
34
        true,
35
        "m/44'/889'/0'/0/",
36
      ),
37
      network_id: "89",
38
      gas: 3000000,
39
      gasPrice: 10000000000000,  // TomoChain requires min 10 TOMO to deploy, to fight spamming attacks
40
    },    // Useful for deploying to TomoChain mainnet
41
    tomomainnet: {
42
      provider: () => new HDWalletProvider(
43
        mnemonic,
44
        "https://rpc.tomochain.com",
45
        0,
46
        1,
47
        true,
48
        "m/44'/889'/0'/0/",
49
      ),
50
      network_id: "88",
51
      gas: 3000000,
52
      gasPrice: 10000000000000,  // TomoChain requires min 10 TOMO to deploy, to fight spamming attacks
53
    },    // Useful for private networks
54
    // private: {
55
      // provider: () => new HDWalletProvider(mnemonic, `https://network.io`),
56
      // network_id: 2111,   // This network is yours, in the cloud.
57
      // production: true    // Treats this network as if it was a public net. (default: false)
58
    // }
59
  },  // Set default mocha options here, use special reporters etc.
60
  mocha: {
61
    // timeout: 100000
62
  },  // Configure your compilers
63
  compilers: {
64
    solc: {
65
      version: "0.5.4",    // Fetch exact version from solc-bin (default: truffle's version)
66
      // docker: true,        // Use "0.5.1" you've installed locally with docker (default: false)
67
      // settings: {          // See the solidity docs for advice about optimization and evmVersion
68
      //  optimizer: {
69
      //    enabled: false,
70
      //    runs: 200
71
      //  },
72
      //  evmVersion: "byzantium"
73
      // }
74
    }
75
  }
76
}
Copied!
3. Remember to update the truffle.js file using your own wallet recovery phrase. Copy the 12 words previously obtained from your wallet and paste it as the value of the mnemonic variable.
1
const mnemonic = '<PUT YOUR WALLET 12-WORD RECOVERY PHRASE HERE>';
Copied!
⚠️ Warning: In production, it is highly recommend storing the mnemonic in another secret file (loaded from environment variables or a secure secret management system)...
4.3 Ganache
You can use Ganache blockchain to test your smart contracts locally, before migrating to a public blockchain like Ethereum (Ropsten) or Tomochain.
On a separate console window, install Ganache and run it:
1
npm install -g ganache-cli
2
ganache-cli -p 8545
Copied!
Ganache will start running, listening on port 8545. Automatically you will have 10 available wallets with their private keys and 100 ETH each. You can use them to test your smart contracts.
5. Adding Tests
We will add now tests to check our smart contracts.
When deploying contracts the first contract will usually be the deployer. This test will check that.
Create GradientTokenTest.js in /test directory and write the following test:
1
const GradientToken = artifacts.require("GradientToken");contract("Gradient token", accounts => {
2
  it("Should make first account an owner", async () => {
3
    let instance = await GradientToken.deployed();
4
    let owner = await instance.owner();
5
    assert.equal(owner, accounts[0]);
6
  });
7
});
Copied!
Here we run the contract block, that deploys our contract. We wait for the contract to be deployed and request owner() which returns owner’s address. Then we assert that the owner address is the same as account[0].
Note: Make sure that Ganache is running (on a different console).
Run the test:
1
truffle test
Copied!
The test should pass. This means that the smart contract works correctly and it did successfully what it was expected to do.
Adding more tests
Every NFT token will have a unique ID. The first minted token has ID: 0, the second one has ID: 1, and on and on…
Now we’ll test the mint function. Add the following test:
1
describe("mint", () => {
2
  it("creates token with specified outer and inner colors", async () => {
3
    let instance = await GradientToken.deployed();
4
    let owner = await instance.owner();    let token0 = await instance.mint("#ff00dd", "#ddddff");
5
    let token1 = await instance.mint("#111111", "#ffff22");
6
    let token2 = await instance.mint("#00ff00", "#ffff00");    let gradients1 = await instance.getGradient( 1 );
7
    assert.equal(gradients1.outer, "#111111");
8
    assert.equal(gradients1.inner, "#ffff22");
9
  });
10
});
Copied!
This test is simple. First we check that we can mint new tokens. We mint 3 tokens. Then we expect that the unique attributes outer and inner of token with tokenId = 1 are saved correctly and we assert it by using the getGradient function that we created before.
The test passed.
6. Deploying
6.1 Start the migration
You should have your smart contract already compiled. Otherwise, now it’s a good time to do it with truffle compile.
Note: Check that you have enough TOMO tokens in your wallet!! I recommend at least 60 TOMO to deploy this smart contract
Back in our terminal, migrate the contract to TomoChain testnet network:
1
truffle migrate --network tomotestnet
Copied!
To deploy to the TomoChain mainnet is very similar:
1
truffle migrate --network tomomainnet
Copied!
The migrations start…
1
Starting migrations...
2
======================
3
> Network name:    'tomotestnet'
4
> Network id:      89
5
> Block gas limit: 840000001_initial_migration.js
6
======================Deploying 'Migrations'
7
   ----------------------
8
   > transaction hash:    0x67c0f12247d0bb0add43e81e8ad534df9cd7d3473ef76f5b60cee3e3d34bae1a
9
   > Blocks: 2            Seconds: 5
10
   > contract address:    0x6056dC38715C7d2703a8aA94ee68A964eaE86fdc
11
   > account:             0x169397F515Af9E93539e0F483f8A6FC115de660C
12
   > balance:             90.05683
13
   > gas used:            273162
14
   > gas price:           10000 gwei
15
   > value sent:          0 ETH
16
   > total cost:          2.73162 ETH> Saving artifacts
17
   -------------------------------------
18
   > Total cost:             2.73162 ETH2_deploy_contracts.js
19
=====================Deploying 'GradientToken'
20
   -------------------------
21
   > transaction hash:    0xca09a87ad8f834644dcb85f8ea89beff74b818eff11d355e0774e6b60c51718c
22
   > Blocks: 2            Seconds: 5
23
   > contract address:    0x8B830F38b798B7b39808A059179f2c228209514C
24
   > account:             0x169397F515Af9E93539e0F483f8A6FC115de660C
25
   > balance:             60.64511
26
   > gas used:            2941172
27
   > gas price:           10000 gwei
28
   > value sent:          0 ETH
29
   > total cost:          29.41172 ETH> Saving artifacts
30
   -------------------------------------
31
   > Total cost:            29.41172 ETHSummary
32
=======
33
> Total deployments:   2
34
> Final cost:          32.14334 ETH
Copied!
Congratulations! You have already deployed your non-fungible token (NFT) to TomoChain! The deployment fees were 32.14 TOMO.
Read the output text on the screen. The NFT token contract address is (yours will be different):
1
0x8B830F38b798B7b39808A059179f2c228209514C
Copied!
⚠️ Note: TomoChain’s smart contract creation fee: gas price 10000 Gwei, gas limit >= 1000000
*** Troubleshooting ***
Error: smart contract creation cost is under allowance. Why?Increasing transaction fees for smart contract creation is one of the ways TomoChain offers to defend against spamming attacks. Solution: edit truffle.js and add more gas/gasPrice to deploy.
Error: insufficient funds for gas * price + value. Why? You don’t have enough tokens in your wallet for gas fees. Solution: you need more funds in your wallet to deploy, go to faucet and get more tokens.
7. Interacting with the smart contract
7.1 Minting new Tokens
Now to create a new Gradient Token you can call:
1
GradientToken(gradientTokenAddress).mint("#001111", "#002222")
Copied!
You can call this function via MyEtherWallet/Metamask or Web3... In a Dapp or game this would probably be called from a button click in a UI.
Let’s use MyEtherWallet (MEW) to interact with the contract. We use MetaMask to connect to the GradientToken owner wallet in TomoChain (testnet), then we will call function mint() to mint the first token.
In MyEtherWallet, under menu Contract > Interact with Contract two things are required:
Contract Address: you got this address when you deployed
ABI: file build/contracts/GradientToken.json, search "abi": [ … ]and copy everything inside brackets, including brackets. Then paste on MEW
On the right you will see a dropdown list with the functions. Select mint. MEW will show two fields: outer and inner. Input two colors, like #ff0000or #0000ff and click the button Write. Confirm with MetaMask.
Here is our contract address, and the new mint transaction:
You can use MEW to Write and to Read functions, like getGradient! This way you can check if values are correct, totalSupply, transfer tokens...
In Ethereum (Ropsten), the Etherscan page with our migrated contract will change after the first token is minted. A new link will be displayed now to track the ERC721 token GRAD.
What’s next?
A few suggestions to continue from here:
You could add a lot of different attributes to your unique NFT tokens
You can connect to a JS front end and show your tokens
You can have some buttons to interact with the tokens (buy, sell, change, transfer, change attributes/colors, etc…)
You can iterate on this basic code and create a new CryptoKitties game :)
Congratulations! You have learned about non-fungible tokens, use-cases of NFTs and how to deploy NFT tokens on TomoChain.
Source Code
The source code for this tutorial is available on Github.
How to deploy an ICO smart contract on TomoChain
An Example of Building a Dapp on TomoChain
Last modified 1yr ago