🚀
Introduction
✨
Enhanced APIs
⛓
Chain APIs
📖
Documentation
💻
Tutorials
📜
Guides
📚
Resources
How to Mint an NFT with Ethers.js (option 2)
This tutorial describes how to mint an NFT on Ethereum using Ethers via the ethers.js library, and our smart contract from Part I: How to Create an NFT. We'll also explore basic test setup.
Estimated time to complete this guide: ~10 minutes
__
If you've already completed "How to Mint an NFT Using Web3.js (option 1)", you can skip this tutorial!
In another tutorial, we learned how to mint an NFT using Web3 and the OpenZeppelin contracts library. In this exercise, we're going to walk you through an alternative implementation using version 4 of the OpenZeppelin library as well as the Ethers.js Ethereum library instead of Web3.
We'll also cover the basics of testing your contract with Hardhat and Waffle. For this tutorial I'm using Yarn, but you can use npm/npx if you prefer.
In all other respects, this tutorial works the same as the Web3 version, including tools such as Pinata and IPFS.
A Quick Reminder
As a reminder, "minting an NFT" is the act of publishing a unique instance of your ERC721 token on the blockchain. This tutorial assumes that that you've successfully deployed a smart contract to the Ropsten network in Part I of the NFT tutorial series, which includes installing Ethers.
Step 1: Create your Solidity contract
OpenZeppelin is library for secure smart contract development. You simply inherit their implementations of popular standards such as ERC20 or ERC721, and extend the behavior to your needs. We're going to put this file at
contracts/MyNFT.sol.1
// Contract based on https://docs.openzeppelin.com/contracts/4.x/erc721
2
// SPDX-License-Identifier: MIT
3
pragma solidity ^0.8.0;
4
5
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
6
import "@openzeppelin/contracts/utils/Counters.sol";
7
8
contract MyNFT is ERC721URIStorage {
9
using Counters for Counters.Counter;
10
Counters.Counter private _tokenIds;
11
12
constructor() ERC721("MyNFT", "MNFT") {}
13
14
function mintNFT(address recipient, string memory tokenURI)
15
public
16
returns (uint256)
17
{
18
_tokenIds.increment();
19
20
uint256 newItemId = _tokenIds.current();
21
_mint(recipient, newItemId);
22
_setTokenURI(newItemId, tokenURI);
23
24
return newItemId;
25
}
26
}
Copied!
Step 2: Create Hardhat tasks to deploy our contract and mint NFT's
Create the file
tasks/nft.ts containing the following:1
import { task, types } from "hardhat/config";
2
import { Contract } from "ethers";
3
import { TransactionResponse } from "@ethersproject/abstract-provider";
4
import { env } from "../lib/env";
5
import { getContract } from "../lib/contract";
6
import { getWallet } from "../lib/wallet";
7
8
task("deploy-contract", "Deploy NFT contract").setAction(async (_, hre) => {
9
return hre.ethers
10
.getContractFactory("MyNFT", getWallet())
11
.then((contractFactory) => contractFactory.deploy())
12
.then((result) => {
13
process.stdout.write(`Contract address: ${result.address}`);
14
});
15
});
16
17
task("mint-nft", "Mint an NFT")
18
.addParam("tokenUri", "Your ERC721 Token URI", undefined, types.string)
19
.setAction(async (tokenUri, hre) => {
20
return getContract("MyNFT", hre)
21
.then((contract: Contract) => {
22
return contract.mintNFT(env("ETH_PUBLIC_KEY"), tokenUri, {
23
gasLimit: 500_000,
24
});
25
})
26
.then((tr: TransactionResponse) => {
27
process.stdout.write(`TX hash: ${tr.hash}`);
28
});
29
});
Copied!
Step 3: Create helpers
You'll notice our tasks imported a few helpers. Here they are.
contract.ts1
import { Contract, ethers } from "ethers";
2
import { getContractAt } from "@nomiclabs/hardhat-ethers/internal/helpers";
3
import { HardhatRuntimeEnvironment } from "hardhat/types";
4
import { env } from "./env";
5
import { getProvider } from "./provider";
6
7
export function getContract(
8
name: string,
9
hre: HardhatRuntimeEnvironment
10
): Promise<Contract> {
11
const WALLET = new ethers.Wallet(env("ETH_PRIVATE_KEY"), getProvider());
12
return getContractAt(hre, name, env("NFT_CONTRACT_ADDRESS"), WALLET);
13
}
Copied!
env.ts1
export function env(key: string): string {
2
const value = process.env[key];
3
if (value === undefined) {
4
throw `${key} is undefined`;
5
}
6
return value;
7
}
Copied!
provider.tsNote that the final
getProvider() function uses the ropsten network. This argument is optional and defaults to "homestead" if omitted. We're using Alchemy of course, but there are several supported alternatives.1
import { ethers } from "ethers";
2
3
export function getProvider(): ethers.providers.Provider {
4
return ethers.getDefaultProvider("ropsten", {
5
alchemy: process.env.ALCHEMY_API_KEY,
6
});
7
}
Copied!
wallet.ts1
import { ethers } from "ethers";
2
import { env } from "./env";
3
import { getProvider } from "./provider";
4
5
export function getWallet(): ethers.Wallet {
6
return new ethers.Wallet(env("ETH_PRIVATE_KEY"), getProvider());
7
}
Copied!
Step 4: Create tests
Under your
test directory, create these files. Note that these tests are not comprehensive. They test a small subset of the ERC721 functionality offered by the OpenZeppelin library, and are intended to provide you with the building blocks to create more robust tests.test/MyNFT.spec.ts (unit tests)1
import { ethers, waffle } from "hardhat";
2
import { Contract, Wallet } from "ethers";
3
import { expect } from "chai";
4
import { TransactionResponse } from "@ethersproject/abstract-provider";
5
import sinon from "sinon";
6
import { deployTestContract } from "./test-helper";
7
import * as provider from "../lib/provider";
8
9
describe("MyNFT", () => {
10
const TOKEN_URI = "http://example.com/ip_records/42";
11
let deployedContract: Contract;
12
let wallet: Wallet;
13
14
beforeEach(async () => {
15
sinon.stub(provider, "getProvider").returns(waffle.provider);
16
[wallet] = waffle.provider.getWallets();
17
deployedContract = await deployTestContract("MyNFT");
18
});
19
20
async function mintNftDefault(): Promise<TransactionResponse> {
21
return deployedContract.mintNFT(wallet.address, TOKEN_URI);
22
}
23
24
describe("mintNft", async () => {
25
it("emits the Transfer event", async () => {
26
await expect(mintNftDefault())
27
.to.emit(deployedContract, "Transfer")
28
.withArgs(ethers.constants.AddressZero, wallet.address, "1");
29
});
30
31
it("returns the new item ID", async () => {
32
await expect(
33
await deployedContract.callStatic.mintNFT(wallet.address, TOKEN_URI)
34
).to.eq("1");
35
});
36
37
it("increments the item ID", async () => {
38
const STARTING_NEW_ITEM_ID = "1";
39
const NEXT_NEW_ITEM_ID = "2";
40
41
await expect(mintNftDefault())
42
.to.emit(deployedContract, "Transfer")
43
.withArgs(
44
ethers.constants.AddressZero,
45
wallet.address,
46
STARTING_NEW_ITEM_ID
47
);
48
49
await expect(mintNftDefault())
50
.to.emit(deployedContract, "Transfer")
51
.withArgs(
52
ethers.constants.AddressZero,
53
wallet.address,
54
NEXT_NEW_ITEM_ID
55
);
56
});
57
58
it("cannot mint to address zero", async () => {
59
const TX = deployedContract.mintNFT(
60
ethers.constants.AddressZero,
61
TOKEN_URI
62
);
63
await expect(TX).to.be.revertedWith("ERC721: mint to the zero address");
64
});
65
});
66
67
describe("balanceOf", () => {
68
it("gets the count of NFTs for this address", async () => {
69
await expect(await deployedContract.balanceOf(wallet.address)).to.eq("0");
70
71
await mintNftDefault();
72
73
expect(await deployedContract.balanceOf(wallet.address)).to.eq("1");
74
});
75
});
76
});
Copied!
tasks.spec.ts (integration specs)1
import { deployTestContract, getTestWallet } from "./test-helper";
2
import { waffle, run } from "hardhat";
3
import { expect } from "chai";
4
import sinon from "sinon";
5
import * as provider from "../lib/provider";
6
7
describe("tasks", () => {
8
beforeEach(async () => {
9
sinon.stub(provider, "getProvider").returns(waffle.provider);
10
const wallet = getTestWallet();
11
sinon.stub(process, "env").value({
12
ETH_PUBLIC_KEY: wallet.address,
13
ETH_PRIVATE_KEY: wallet.privateKey,
14
});
15
});
16
17
describe("deploy-contract", () => {
18
it("calls through and returns the transaction object", async () => {
19
sinon.stub(process.stdout, "write");
20
21
await run("deploy-contract");
22
23
await expect(process.stdout.write).to.have.been.calledWith(
24
"Contract address: 0x610178dA211FEF7D417bC0e6FeD39F05609AD788"
25
);
26
});
27
});
28
29
describe("mint-nft", () => {
30
beforeEach(async () => {
31
const deployedContract = await deployTestContract("MyNFT");
32
process.env.NFT_CONTRACT_ADDRESS = deployedContract.address;
33
});
34
35
it("calls through and returns the transaction object", async () => {
36
sinon.stub(process.stdout, "write");
37
38
await run("mint-nft", { tokenUri: "https://example.com/record/4" });
39
40
await expect(process.stdout.write).to.have.been.calledWith(
41
"TX hash: 0xd1e60d34f92b18796080a7fcbcd8c2b2c009687daec12f8bb325ded6a81f5eed"
42
);
43
});
44
});
45
});
Copied!
test-helpers.ts Note this require the NPM libraries imported, including sinon, chai, and sinon-chai. The sinon.restore() call is necessary due to the use of stubbing.1
import sinon from "sinon";
2
import chai from "chai";
3
import sinonChai from "sinon-chai";
4
import { ethers as hardhatEthers, waffle } from "hardhat";
5
import { Contract, Wallet } from "ethers";
6
7
chai.use(sinonChai);
8
9
afterEach(() => {
10
sinon.restore();
11
});
12
13
export function deployTestContract(name: string): Promise<Contract> {
14
return hardhatEthers
15
.getContractFactory(name, getTestWallet())
16
.then((contractFactory) => contractFactory.deploy());
17
}
18
19
export function getTestWallet(): Wallet {
20
return waffle.provider.getWallets()[0];
21
}
Copied!
Step 5: Configuration
Here's our fairly bare bones
hardhat.config.ts.1
import("@nomiclabs/hardhat-ethers");
2
import("@nomiclabs/hardhat-waffle");
3
import dotenv from "dotenv";
4
// You need to export an object to set up your config
5
// Go to https://hardhat.org/config/ to learn more
6
7
const argv = JSON.parse(env("npm_config_argv"));
8
if (argv.original !== ["hardhat", "test"]) {
9
require('dotenv').config();
10
}
11
12
import("./tasks/nft");
13
14
import { HardhatUserConfig } from "hardhat/config";
15
16
const config: HardhatUserConfig = {
17
solidity: "0.8.6",
18
};
19
20
export default config;
Copied!
Note the conditional to only invoke dotenv if we're not running tests. You might not want to run this in production, but rest assured that dotenv will silently ignore it if the .env file isn't present.
Running Our Tasks
Now that we've put these files in place, we can run
hardhat to see our tasks (excluding the built-in tasks for brevity).1
AVAILABLE TASKS:
2
3
deploy-contract Deploy NFT contract
4
mint-nft Mint an NFT
Copied!
Forget the arguments to your task? No problem.
1
$ hardhat help deploy-contract
2
3
Usage: hardhat [GLOBAL OPTIONS] deploy-contract
4
5
deploy-contract: Deploy NFT contract
Copied!
Running Our Tests
To run our tests, we run
hardhat test.1
mintNft
2
✓ calls through and returns the transaction object (60ms)
3
4
MyNFT
5
mintNft
6
✓ emits the Transfer event (60ms)
7
✓ returns the new item ID
8
✓ increments the item ID (57ms)
9
✓ cannot mint to address zero
10
balanceOf
11
✓ gets the count of NFTs for this address
12
13
14
6 passing (2s)
15
16
✨ Done in 5.66s.
Copied!
Summary
In this tutorial, we've created a firm foundation for a well tested NFT infrastructure based on Solidity. The wallet provided by
waffle.provider.getWallets() links to a local fake Hardhat Network account that conveniently comes preloaded with an eth balance that we can use to fund our test transactions.