1. How to Develop an NFT Smart Contract (ERC721) with Alchemy

Developing a Smart Contract with Solidity and deploying it on the blockchain might sound daunting at first: solidity, security, gas optimization, developer environment, and gas fees, are only some of the things you’ll need to go through to host your code on the blockchain.
Luckily though, in the last few months, a lot of tools have been released for developers to make their Smart contracts development jobs much easier. 
Tools like the OpenZeppelin Wizard that offers developers click and write functionalities to create composable and secure smart contracts in no time, used with Web3 developer tools like Alchemy, make the experience of writing a deploying code on the blockchain easy, fast, and reliable like never before.
In this tutorial, you're going to learn how to develop and deploy an ERC721 (NFT) smart contract using Alchemy, OpenZeppelin, Remix, and Ethereum Rinkeby.
More precisely, you will learn:
How to write and modify the smart contract using OpenZeppelin and Remix
Get free Rinkeby ETH using rinkebyfaucet.com
Deploy it on the Ethereum Rinkeby testnet blockchain to save on gas fees
Host the NFT tokens metadata on IPFS using Filebase.
Mint an NFT and visualize it on OpenSea
You can also follow the video tutorial:
Let’s start by creating the smart contract.
Develop the ERC721 Smart Contract With the OpenZeppelin Contract Wizard.
As said before, in this tutorial, you're going to use the OpenZeppelin Wizard to create the smart contract, for two main reasons:
It’s secure.
It offers standard complaining smart contracts.
When it comes to writing smart contracts, security is key. There are tons of examples of smart contract exploits that have seen hundreds of millions of dollars stolen by malicious actors due to bad security.
You don’t want someone to steal all of your precious cryptos or NFTs once you’ll deploy on the blockchain right?
OpenZeppelin serves this purpose, being one of the biggest maintainers of smart contract standards (ERC20, ERC721, etc), allowing developers to use thoroughly audited code to develop reliable contracts.
The first thing you'll need to do to develop our ERC721 NFT smart contract is to go on the Open Zeppelin Smart contract wizard page.​
Once on the page, you will see the following editor:
​
​
Click on the ERC721 button on the top left corner, to select the type of ERC standard to use and the kind of contract you want to write:
​
​
Now that you've selected the contract standard, on the left-hand side menu you should see a number of options:
Let’s start by choosing the name and the symbol of our Tokens. Click on the text box with “MyToken” and give it a name, do the same with the Symbol, and leave the base URI field blank (the token name will be used by OpenSea and Rarible as the name of the collection).
​
​
Select the NFT (ERC721) Token Features
Now you'll need to select the features that you want to integrate into our Smart contract, right after the “settings” section, you’ll find the “features” section where you’ll be able to select the different modules to include in your smart contract.
​
​
In this case, you're going to select the following integrations: 
Mintable will create a mint function only callable by privileged accounts 
Autoincrement IDs will automatically assign incremental IDs to your NFTs 
Enumerable will give you access to on chain Tokens enumeration and functions such as “totalSupply”, not present in the default ERC721 integration URI storage, to associate metadata and images to each of your NFTs
URI Storage to be able to associate URIs to our NFTs
​
​
For the sake of this tutorial, and because you don’t want to create any kind of Tokenomic around our NFTs, leave the following modules unticked:
Burnable - to burn tokens
Pausable - to pause tokens transfers, sales, etc
Votes - gives access to governance like features like delegates and votes
If you want to learn more about these modules, check the official OpenZeppelin documentation about the ERC721 standard.​
Now that you've selected the features you want, OpenZeppelin Wizard will populate the code of the Smart Contract, it should look as follow:
1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.4;
3
​
4
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
5
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
6
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
7
import "@openzeppelin/contracts/access/Ownable.sol";
8
​
9
contract Alchemy is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
10
    constructor() ERC721("Alchemy", "ALC") {}
11
​
12
    function safeMint(address to, uint256 tokenId, string memory uri)
13
        public
14
        onlyOwner
15
    {
16
        _safeMint(to, tokenId);
17
        _setTokenURI(tokenId, uri);
18
    }
19
​
20
    // The following functions are overrides required by Solidity.
21
​
22
    function _beforeTokenTransfer(address from, address to, uint256 tokenId)
23
        internal
24
        override(ERC721, ERC721Enumerable)
25
    {
26
        super._beforeTokenTransfer(from, to, tokenId);
27
    }
28
​
29
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
30
        super._burn(tokenId);
31
    }
32
​
33
    function tokenURI(uint256 tokenId)
34
        public
35
        view
36
        override(ERC721, ERC721URIStorage)
37
        returns (string memory)
38
    {
39
        return super.tokenURI(tokenId);
40
    }
41
​
42
    function supportsInterface(bytes4 interfaceId)
43
        public
44
        view
45
        override(ERC721, ERC721Enumerable)
46
        returns (bool)
47
    {
48
        return super.supportsInterface(interfaceId);
49
    }
50
}
Copied!
It’s time to copy our code and bring it on Remix IDE to modify and deploy it on the Blockchain.
Modify and Deploy your ERC721 contract with REMIX IDE
Now that you have your ERC721 smart contract, let's modify, and deploy it on the Rinkeby Testnet. To do so, you'll use Remix IDE, a free and web based integrated development environment specifically designed for smart contract development with Solidity.
First of all, as you might have noticed, on top of the OpenZeppelin Wizard editor, there’s the button “Open in Remix”:
​
​
Clicking on it will open REMIX IDE in a new tab of your browser.
Using Remix to Modify the NFT Smart Contract
Starting from the top of the contract, there's the “SPDX-License-Identifier” that specifies the type of license your code will be published under - it’s good practice in web3 applications to keep the code open source as it will ensure trustworthiness.
1
// SPDX-License-Identifier: MIT
Copied!
Then there's the pragma - the version of the compiler you'll want to use to compile the smart contract code. The little “^” symbol, tells the compiler that every version between 0.8.0 to 0.8.9 is suitable to compile our code.
1
pragma solidity ^0.8.4;
Copied!
Then we're importing a bunch of libraries, and initializing the smart contract.
1
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
2
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
3
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
4
import "@openzeppelin/contracts/access/Ownable.sol";
5
import "@openzeppelin/contracts/utils/Counters.sol";
Copied!
We're then initializing the contract, inheriting from all the standards we're importing from OpenZeppelin repository:
1
contract Alchemy is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {...}
Copied!
As you can notice, the safeMint function, has the “only owner” modifier - this will allow only the owner of the smart contract (the wallet address that deployed the smart contract) to mint NFTs. Chances are you want anyone to mint NFTs, to do so you'll need to to remove the onlyOwner modifier from the Mint function.
1
function safeMint(address to, string memory uri) public {
2
        uint256 tokenId = _tokenIdCounter.current();
3
        _tokenIdCounter.increment();
4
        _safeMint(to, tokenId);
5
        _setTokenURI(tokenId, uri);
6
    }
Copied!
You can also remove it from the contract declaration "Ownable", and the library imports 
1
import "@openzeppelin/contracts/access/Ownable.sol";
Copied!
Now that everyone will be able to mint our NFTs, you'll need to avoid people from minting more NFTs than the max number of NFTs in our collection. To do so let's specify the max number of mintable NFTs. 

Let’s say want the users to be able to mint up to a total of 10,000 NFTs. To do so, let’s create a new uint256 variable, call it MAX_SUPPLY, and assign it 10,000.
1
    Counters.Counter private _tokenIdCounter;
2
    uint256 MAX_SUPPLY = 100000;
3
​
4
    constructor() ERC721("Alchemy", "ALCH") {}
Copied!
Next, let’s move into the safeMint function and add a require statement on line 18:
1
require(_tokenIdCounter.current() <= MAX_SUPPLY, "I'm sorry we reached the cap");
Copied!
Let's spend a couple of words to better understand what is the "require" statement in Solidity.
You can read more about the Solidity "require" statement, in the official documentation.
Now that you've limited the max supply of our NFTs, is time to compile the smart contract and deploy it on the Rinkeby Testnet. To do so, you'll need to create a free account on Alchemy.com, add it as a node provider on Metamask, and get some free Rinkeby ETH.
Create a Free Alchemy Account
First of all, le's need to navigate to alchemy.com click on “Login” and create a new account:
​
Select the Ethereum ecosystem:
​
​
Give your application app and team a name, choose the Rinkeby network and click on create App:
​
​
Once you'll have completed the onboarding process, we'll be redirected to the dashboard. Click on the application with the name you decided, in this case, “test”, click on the “VIEW KEY” button on the top right corner, and copy the HTTP URL:
​
​
Next, you'll need to add Alchemy to Metamask as a Rineby RPC Provider. If you don’t have Metamask installed, make sure to follow this guide to add it to your browser and create a new wallet.
Add Alchemy Rinkeby on Your Metamask Wallet
Once Metamask will be installed, click on the Network dropdown menu, and on “add network”
.
You'll be redirected to the following page, where you'll need to fill in the Rinkeby Network and RPC URL info.
​
​
Add the following information to the form: 
Network name: Alchemy Rinkeby 
New RPC URL: the HTTP URL of the Rinkeby Alchemy Application 
Chain ID: 4 
Currency Symbol: ETH 
Block Explorer: https://rinkeby.etherscan.io/
Amazing, you just added Rinkeby to Metamask, using Alchemy! 🎉
It’s now time to deploy our Smart Contract on Rinkeby, but first, you'll need to get some Rikeby Test ETH.
Get Free Rinkeby Test ETH
Getting Rinkeby Test ETH is super simple, just navigate to rinkebyfaucet.com, copy the wallet address into the text bar and click on “Send Me ETH”:
​
​
After 10-20 seconds you'll see the Rinkeby ETH appearing in the Metamask Wallet.
You'll be able to get up to 0.1 ETH every 24 without logging in, or 0.5 with an Alchemy account.
Now that you've the test ETH, it’s time to compile and deploy our NFT smart contract on the blockchain.
Compile and Deploy the NFT Smart Contract on the Rinkeby Testnet
Back to Remix, let’s click on the compiler menu on the left hand side of the page and click on The blue “Compile” button:
Then click on the “Deploy and Run Transactions menu, click on the Environment dropdown menu and select “injected Web3”:
Make sure the Metamask wallet is on the Alchemy Rinkeby network, select the NFT Smart contract from the Contract dropdown menu and click on Deploy.
​
​
A Metamask pop-up window will appear, click on "sign", and proceed to pay the gas fees.
If everything worked as expected, after 10 seconds you should see the contract listed under Deployed Contracts:
​
​
Now that the Smart contract is deployed on the Rinkeby testnet, it’s time to mint our NFTs, but first, you'll need to create and upload the metadata on IPFS, let’s understand what we mean with the term “metadata”.
What is NFTs Metadata?
​
​
For OpenSea to pull in off-chain metadata for ERC721 tokens, the contract will need to return a URI pointing to the hosted metadata. To find this URI, OpenSea, Rarible and other popular marketplaces will use the tokenURI method contained in the ERC721Uristorage standard. 
The tokenURI function in the ERC721 should return an HTTP or IPFS URL, such as ipfs://bafkreig4rdq3nvyg2yra5x363gdo4xtbcfjlhshw63we7vtlldyyvwagbq. When queried, this URL should return a JSON blob of data with the metadata for your token.

You can read more about metadata standars on the official OpenSea documentation.
How to Format Your NFT Metadata
According to the OpenSea documentation, the NFT Metadata should be stored in a .json file and structured as follow:
1
{ 
2
  "description": "YOUR DESCRIPTION",
3
  "external_url": "YOUR URL",
4
  "image": "IMAGE URL",
5
  "name": "TITLE", 
6
  "attributes": [
7
    {
8
      "trait_type": "Base", 
9
      "value": "Starfish"
10
    }, 
11
    {
12
      "trait_type": "Eyes", 
13
      "value": "Big"
14
    }, 
15
    {
16
      "trait_type": "Mouth", 
17
      "value": "Surprised"
18
    }, 
19
    {
20
      "trait_type": "Level", 
21
      "value": 5
22
    }, 
23
    {
24
      "trait_type": "Stamina", 
25
      "value": 1.4
26
    }, 
27
    {
28
      "trait_type": "Personality", 
29
      "value": "Sad"
30
    }, 
31
    {
32
      "display_type": "boost_number", 
33
      "trait_type": "Aqua Power", 
34
      "value": 40
35
    }, 
36
    {
37
      "display_type": "boost_percentage", 
38
      "trait_type": "Stamina Increase", 
39
      "value": 10
40
    }, 
41
    {
42
      "display_type": "number", 
43
      "trait_type": "Generation", 
44
      "value": 2
45
    }
46
  }
47
​
Copied!
Here's a brief explanation of what each property stores:
image
This is the URL to the image of the item. Can be just about any type of image (including SVGs, which will be cached into PNGs by OpenSea), and can be IPFS URLs or paths. We recommend using a 350 x 350 image. 
image_data
Raw SVG image data, if you want to generate images on the fly (not recommended). Only use this if you're not including the image parameter.
external_url:
This is the URL that will appear below the asset's image on OpenSea and will allow users to leave OpenSea and view the item on your site. 
description
A human readable description of the item. Markdown is supported. 
​
name
Name of the item
attributes
 These are the attributes for the item, which will show up on the OpenSea page for the item. (see below) 
background_color
Background color of the item on OpenSea. Must be a six-character hexadecimal without a pre-pended #.
animation_url
A URL to a multi-media attachment for the item. The file extensions GLTF, GLB, WEBM, MP4, M4V, OGV, and OGG are supported, along with the audio-only extensions MP3, WAV, and OGA. Animation_url also supports HTML pages, allowing us to build rich experiences and interactive NFTs using JavaScript canvas, WebGL, and more. Scripts and relative paths within the HTML page are now supported. However, access to browser extensions is not supported. youtube_url A URL to a YouTube video
Now that we have a brief understanding of what will be contained in your tokens metadata, let's learn how to create it and store it on IPFS.
Creating and Uploading the Metadata on IPFS
First of all, navigate to filebase.com and create a new account.
Once logged in, click on the bucket button on the left hand side menu, and create a new bucket:
​
​
Navigate into the bucket, click on the upload button and upload the image you want to use for your NFT, I’ll use the following. 

Once uploaded click on it and copy the IPFS Gateway URL:
​
​
Using any text editor, paste the following JSON code:
1
{ 
2
  "description": "This NFT proves I've created and deployed my first ERC20 smart contract on Rinkeby with Alchemy Road to Web3",
3
  "external_url": "Alchemy.com",
4
  "image": "https://ipfs.filebase.io/ipfs/bafybeihyvhgbcov2nmvbnveunoodokme5eb42uekrqowxdennt2qyeculm",
5
  "name": "A cool NFT", 
6
  "attributes": [
7
    {
8
      "trait_type": "Base", 
9
      "value": "Starfish"
10
    }, 
11
    {
12
      "trait_type": "Eyes", 
13
      "value": "Big"
14
    }, 
15
    {
16
      "trait_type": "Mouth", 
17
      "value": "Surprised"
18
    }, 
19
    {
20
      "trait_type": "Level", 
21
      "value": 5
22
    }, 
23
    {
24
      "trait_type": "Stamina", 
25
      "value": 1.4
26
    }, 
27
    {
28
      "trait_type": "Personality", 
29
      "value": "Sad"
30
    }, 
31
    {
32
      "display_type": "boost_number", 
33
      "trait_type": "Aqua Power", 
34
      "value": 40
35
    }, 
36
    {
37
      "display_type": "boost_percentage", 
38
      "trait_type": "Stamina Increase", 
39
      "value": 10
40
    }, 
41
    {
42
      "display_type": "number", 
43
      "trait_type": "Generation", 
44
      "value": 2
45
    }
46
  }
47
​
Copied!
And save the file as "metadata.json". Move back to Filebase and upload the metadata.json file in the same bucket where we uploaded the Image.
Lastly, click on the CID and copy it, we’ll need it in the next part to build the token URI when minting out NFT:
​
​
Mint Your Rinkeby NFT
Go back to Remix and in the Deploy & Run Transactions menu, go under “deployed contracts” - and click on the contract we just deployed, it will open up a list of all the methods contained in your Smart contact:
​
​
Orange methods are methods that actually write on the blockchain whereas Blue methods are methods learning from the blockchain.
Click on the safeMint method dropdown icon and paste your address and the following string into the uri field:
ipfs://<your_metadata_cid>
Clicking on transact will create a Metamask popup prompting you to pay the gas fees.
Click on "sign" and go on minting your first NFT! 

Wait a couple of seconds and, to make sure the mint went through successfully, copy and paste your address in the balanceOf method input, and run it - it should show you have 1 NFT. 

Do the same with the tokenUri method, inserting “0” as the id argument - it should display your tokenURI.
Great! You just minted your first NFT! 🎉

Now it’s time to move to OpenSea to check if the metadata is benign read.
Visualize Your NFT on OpenSea
Navigate to testnets.opensea.io and log in with your Metamask wallet. Then click on your profile picture, you should see your newly minted NFT there. If the image is not yet visible, click on it, and click on the “refresh metadata” button.
​
​
Sometimes OpenSea has hard times recognizing testnet metadata - and could take up to 6 hours to see it. After some time your NFT should be visible as follow:
​
​
Congratulations, you have successfully created, modified, and deployed your first smart contract. Minted your first NFT, and published your image on IPFS! 🔥
Next step? Why don’t you modify your smart contract to allow users to only mint only up to a certain number of NFTs? 5 per user should be enough, or someone might start minting thousands of NFTs!
To do so, look into the mapping type, here there’s an amazing guide to walk you through it.
Want the video version of this tutorial? Subscribe to the Alchemy YouTube channel and join our Discord community to find thousands of developers ready to help you out! 
We are always looking to improve this learning journey, please share any feedback you have with us! https://alchemyapi.typeform.com/roadtofeedback​