Fantom: ERC-721 Collection contract with Truffle & OpenZeppelin

• This tutorial shows how to build and deploy a straightforward ERC-721 contract on the Fantom testnet.
• You’ll leverage Truffle and OpenZeppelin to set up and compile the NFT collection, which can be minted by anyone.
• Once deployed, you can verify the contract on FTMScan for easy interactions like minting or querying balances.
• You can eventually take the same approach for Fantom mainnet and list your collection on an NFT marketplace such as Artion.

​

Main article

• Create a simple ERC-721 collection contract that allows anyone to mint new non-fungible tokens in the collection.
• Deploy the contract on the Fantom testnet through a node deployed with Chainstack.
• Interact with the deployed contract.
• See that you can register your collection on an NFT market.

​

Prerequisites

• Chainstack account to deploy a Fantom node.
• Truffle Suite to create and deploy contracts.
• OpenZeppelin Contracts to use the audited ERC-721 libraries to create your ERC-721 collection contract.

​

Overview

1. With Chainstack, create a public chain project.
2. With Chainstack, join the Fantom testnet.
3. With Chainstack, access your Fantom node credentials.
4. With OpenZeppelin, create an ERC-721 contract.
5. With Truffle, compile and deploy the contract through your Fantom node.
6. With FTMScan, verify the deployed contract.

​

Step-by-step

​

Create a public chain project

​

Join the Fantom testnet

​

Get your Fantom node access and credentials

​

Install OpenZeppelin Contracts

​

Install Truffle Suite

​

Create the contract

1. On your machine, in the contract directory, initialize Truffle:
   Shell

   Copy

   truffle init
   

   This will generate the Truffle boilerplate structure:
   Copy

   .
   ├── contracts
   │   └── .gitkeep
   ├── migrations
   │   └── .gitkeep
   ├── test
   │   └── .gitkeep
   └── truffle-config.js
   

2. Go to the contracts directory. In the directory, create your ERC-721 contract Fantom721Collection.sol.
   solidity

   Copy

   //SPDX-License-Identifier: MIT
   pragma solidity ^0.8;
   
   import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
   
   contract Fantom721Collection is ERC721URIStorage {
       uint256 public tokenCounter;
       constructor () public ERC721 ("COLLECTION_NAME", "COLLECTION_TICKER"){
           tokenCounter = 0;
       }
   
       function createCollectible(string memory tokenURI) public returns (uint256) {
           uint256 newItemId = tokenCounter;
           _safeMint(msg.sender, newItemId);
           _setTokenURI(newItemId, tokenURI);
           tokenCounter = tokenCounter + 1;
           return newItemId;
       }
   
   }
   

   The contract implementation is the following:
   • The contract uses OpenZeppelin audited ERC-721 contract templates.
   • The contract is a mintable collection. Anyone can add a token to the collection through createCollectible.
   • COLLECTION_NAME — any name to give to your collection
   • COLLECTION_TICKER — any ticker for your collection
3. Create 2_deploy_contracts.js in the migrations directory.
   JavaScript

   Copy

   module.exports = function(deployer) {
   var Fantom721Collection = artifacts.require("./Fantom721Collection.sol");
     deployer.deploy(Fantom721Collection);
   };
   

   This will create the contract deployment instructions for Truffle.

​

Compile and deploy the contract

1. Install HDWalletProvider. HDWalletProvider is Truffle’s separate npm package used to sign transactions. Run:
   Shell

   Copy

   npm install @truffle/hdwallet-provider
   

2. Edit truffle-config.js to add:
   • HDWalletProvider
   • Your Fantom node access and credentials
   • Your Fantom account that you will use to deploy the contract.
     JavaScript

     Copy

     const HDWalletProvider = require("@truffle/hdwallet-provider");
     const private_key = 'YOUR_PRIVATE_KEY';
     
     module.exports = {
      networks: {
         testnet: {
             provider: () => new HDWalletProvider(private_key, "YOUR_CHAINSTACK_ENDPOINT"),
             network_id: 4002
         }
        },
     
      compilers: {
         solc: {
         version: "0.8.9",
         }
       }
     };
     

   where
   • testnet — any network name that you will pass to the truffle migrate --network command.
   • HDWalletProvider — Truffle’s custom provider to sign transactions.
   • YOUR_PRIVATE_KEY — the private key of your Fantom account that will deploy the contract. The account must have enough FTM funds to run the deployment. See also Fantom testnet faucet.
   • YOUR_CHAINSTACK_ENDPOINT — your Fantom node HTTPS endpoint deployed with Chainstack. See also View node access and credentials and Tools.
   • network_id — the network ID of the Fantom network: mainnet is 250, testnet is 4002.
   • solc — the Solidity compiler version that Truffle must use.
3. Run:
   Shell

   Copy

   truffle migrate --network testnet
   

   This will engage 2_deploy_contracts.js and deploy the contract to the Fantom testnet as specified in truffle-config.js.

​

Interact with the contract

​

Flatten your contract code

1. Install Truffle Flattener. Run:
   Shell

   Copy

   npm install truffle-flattener
   

2. Flatten the contract. In the contracts directory, run:
   Shell

   Copy

   npx truffle-flattener Fantom721Collection.sol > FlatFantom721Collection.sol
   

3. Clean up the licensing information. The flattened contract will have the same licensing note imported from each of the files. Multiple licensing notes in one file break the FTMScan verification, so you have to leave one licensing note for the entirety of the flattened contract. The easiest way to clean up is to search for the SPDX mentions in the file and remove all of them except for the very first one.

​

Verify the deployed contract on FTMScan

1. Go to FTMScan testnet.
2. Find your deployed contract. The address of your contract should have been printed by Truffle at the end of the deployment in the contract address field.
3. On the contract page on FTMScan, click Contract > Verify and Publish.
4. In Compiler Type, select Solidity (Single file).
5. In Compiler Version, select v0.8.9. This is the version this tutorial used to compile the contract.
6. In Open Source License Type, select MIT License (MIT).
7. Click Continue.
8. Keep the Optimization option set to No as Truffle does not use optimization by default.
9. Paste the entirety of your flattened .sol contract in the Enter the Solidity Contract Code below field.
10. Click Verify and Publish.

​

Interact with the contract

​

Mint an NFT in the collection

• MetaMask installed and unlocked as you will need it to call the contract. See Fantom tooling: MetaMask.
• Testnet FTM on the account to pay for the transaction. See Fantom testnet faucet.

1. On FTMScan, on your contract, click Contract.
2. Click Write Contract.
3. Click Connect to Web3.
4. Under createCollectible, in the tokenURI field, provide any string to serve as metadata for this specific NFT. See also OpenZeppelin ERC-721 for a metadata example.
5. Click Write.

​

Check the balances

1. On FTMScan, on your contract, click Contract.
2. Click Read Contract.
3. Scroll to the balanceOf field.
4. In the owner (address) field, provide the address of the account you used to deploy the contract.
5. Click Query.

1. On FTMScan, on your contract, click Contract.
2. Click Read Contract.
3. Check the tokenCounter field.

​

Listing on an NFT market

​

Conclusion

Ake

Director of Developer Experience @ Chainstack Talk to me all things Web320 years in technology | 8+ years in Web3 full time years experienceTrusted advisor helping developers navigate the complexities of blockchain infrastructure