How to sell NFTS to a list of approved addresses

Step 1

Creating a merkle root from all approved addresses​

The best way to create a whitelist in solidity is by generating a merkle tree. It is a data structure that can store many data in a limited space which ends up being a merkle root.

To be able to generate this parameter, you will need to use this code snippet:

import { ethers } from "ethers"
import { MerkleTree } from "merkletreejs"

// Compute the root of the merkletree
const addresses = [
    /* The addresses of the wallets allowed to mint */
]
const leaves = addresses.map((addr) => ethers.keccak256(addr))
const merkleTree = new MerkleTree(leaves, ethers.keccak256, { sortPairs: true })
const rootHash = merkleTree.getRoot()

Step 2

Deploying the Sale contract from API​

After you computed the root of the Merkle Tree, you can deploy the contract:

const axios = require("axios")

const axiosInstance = axios.create({
	baseURL: "https://api.starton.com",
	headers: { "x-api-key": "PUT HERE YOUR API KEY" },
})

axiosInstance
	.post("/v3/smart-contract/from-template", {
		network: "",
		signerWallet: "",
		templateId: "ERC721_SALE",
		name: "My first NFT Whitesale",
		description: "This is my first NFT Whitesale ",
		params: [
			"", // definitiveTokenAddress
			"", // definitiveMerkleRoot
			"", // definitivePrice
			"", // definitiveStartTime
			"", // definitiveEndTime
			"", // definitiveMaxTokensPerAddress
			"", // definitiveMaxSupply
			"", // definitiveFeeReceiver
		],
		speed: "average",
	})
	.then((response) => {
		console.log(response.data)
	})

• definitiveTokenAddress: The address of the previously deployed ERC721
• definitiveMerkleRoot: The merkle root
• definitivePrice: The price to sell each token
• definitiveStartTime: The time when the sale will start
• definitiveEndTime: The time when the sale will end
• definitiveMaxTokensPerAddress: The max amount of tokens a single address can buy
• definitiveMaxSupply: The total amount of tokens that can be sold
• definitiveFeeReceiver: The address that will receive all the price paid to mint

Step 3

Granting role on your base contract​

For the whitelist sale contract to be able to mint new tokens, you are going to need to grant the newly created contract the MINTER_ROLE over the base contract deployed.

Retrieving the MINTER_ROLE​

First, let's get the minter role:

const axios = require("axios")

const axiosInstance = axios.create({
	baseURL: "https://api.starton.com",
	headers: {
		"x-api-key": "PUT HERE YOUR API KEY",
	},
})

axiosInstance
	.post("/v3/smart-contract/{network}/{YOUR_BASE_CONTRACT}/read", {
		functionName: "MINTER_ROLE",
		params: [],
	})
	.then((response) => {
		console.log(response.data)
	})

Granting the minter role to your Sale contract​

To grant the minter role to your contract, you can use the following request:

const axios = require("axios")

const axiosInstance = axios.create({
	baseURL: "https://api.starton.com",
	headers: { "x-api-key": "PUT HERE YOUR API KEY" },
})

axiosInstance
	.post("/v3/smart-contract/${network}/${YOUR SMART CONTRAT ADDRESS}/call", {
		functionName: "grantRole(bytes32,address)",
		params: [
			"0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6", // MINTER_ROLE
			"", // account
		],
		signerWallet: "",
		speed: "average",
	})
	.then((response) => {
		console.log(response.data)
	})

• account: The whitelist sale contract address

Step 4

Interacting with the contract​

You can access different parameters of the contract using these functions:

And finally you can use the withdraw function to withdraw all the fees earned to the definitiveFeeReceiver.

• definitiveMaxTokensPerAddress: The max amount of tokens a single address can buy
• definitiveMaxSupply: The total amount of tokens that can be sold
• definitiveFeeReceiver: The address that will receive all the price paid to mint

Minting a NFT​

Now that the contract is deployed, every user can mint a token.

To be able to do this, every user will need to specify two parameters while minting:

• the address of the receiver of the NFT
• the merkle proof

This proof is also linked to the merkle tree and it can prove that an address is inside the merkle tree To be able to generate it, you can use this code snippet:

import { keccak256 } from "ethers/lib/utils"
import { MerkleTree } from "merkletreejs"

// Compute the root of the merkletree
const addresses = [
	/* The addresses of the wallets allowed to mint */
]
const leaves = addresses.map((addr) => keccak256(addr))
merkleTree = new MerkleTree(leaves, keccak256, { sortPairs: true })

// replace MINTER_ADDRESS with the address of the account that will mint the NFT
const proof = merkleTree.getHexProof(keccak256(MINTER_ADDRESS))

Users will then be able to mint a new token using their wallet such as metamask with the right parameters.

Step 5

Integrating the Sale to your application​

Congrats! You're now all set for your NFT Sale. You can connect this smart contract using the mint function to a button. By, using etherjs/web3js, call the mint function of the sale contract with the desired address.

You can also give more information on this mint page such as NFT left to mints or end time of the sale.

Shall we continue ?​