How to Create an NFT Allowlist Based on Ownership

The most successful NFT PFP projects usually like to reward their community with continuing utility. One of the most common ways of doing this is by allowing existing holders to mint free NFTs from their subsequent collections.

1024

BAYC NFT holders were able to mint MAYC NFTs for free at the time of release

Another fairly common design paradigm is to allow NFT holders of a project you do not own to mint NFTs from your collection for free or at a discounted rate. This is usually done to incentivize some of the most active collectors in the NFT ecosystem to participate in your project.

Fortunately, building allowlists that query ownership data on already deployed contracts is fairly simple on Ethereum and other EVM-based blockchains. In this article, we will write an NFT collectible smart contract using Solidity and Hardhat that allows users to mint NFTs only if they own an NFT from another pre-determined collection.

Creating the Allowlist Contract

Step 1: Install Node and npm

In case you haven’t already, install node and npm on your local machine. Make sure that node is at least v14 or higher by typing the following in your terminal:

$ node -v

Step 2: Create a Hardhat project

We’re going to set up our project using Hardhat, the industry-standard development environment for Ethereum smart contracts. Additionally, we’ll also install OpenZeppelin contracts.

To set up Hardhat, run the following commands in your terminal:

bash

$ mkdir nft-allowlist && cd nft-allowlist
> npm init -y
> npm install --save-dev hardhat
> npx hardhat

Choose Create a Javascript project from the menu and accept all defaults. To ensure everything is installed correctly, run the following command in your terminal:

bash

$ npx hardhat test

To install OpenZeppelin:

bash

$ npm install @openzeppelin/contracts

Step 3: Write the original NFT smart contract

In order to create an NFT smart contract that allows mints based on ownership of another NFT collection, we need to either get the deployed address of the original NFT collection or write one from scratch.

Since we are working in a local development environment, we will do the latter. Create a file called OGCollection.sol in the contracts folder and add the following code:

OGCollection.sol

1 // SPDX-License-Identifier: MIT
2 pragma solidity ^0.8.4;
3 
4 import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
5 import "@openzeppelin/contracts/utils/Counters.sol";
6 
7 contract OGCollection is ERC721 {
8 
9 	using Counters for Counters.Counter;
10     Counters.Counter private _tokenIds;
11 
12     constructor() ERC721("Original Collection", "OGC") {}
13 		
14 		function mintNft() public {
15 		    uint256 tokenId = _tokenIds.current();
16         _mint(msg.sender, tokenId);
17         _tokenIds.increment();
18 		}
19 }

Step 4: Write the NFT Smart Contract with Allowlist

Let’s now write an NFT smart contract that allows mint only if a wallet holds an NFT from the OG collection above. In order to do this, we will have to invoke the balanceOf() function of OGCollection provided to it by OpenZeppelin’s ERC-721 implementation.

To make sure that our contract can actually call the aforementioned function, we need to provide it with the function’s signature. We will do this using Solidity interfaces.

In the contracts folder, create a new file called NftWithAllowlist.sol and add the following code:

NftWithAllowlist.sol

1 //SPDX-License-Identifier: MIT
2 pragma solidity ^0.8.0;
3 
4 import "hardhat/console.sol";
5 import "@openzeppelin/contracts/utils/Counters.sol";
6 import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
7 
8 interface OGCollectionInterface {
9     // Define signature of balanceOf
10     function balanceOf(address owner) external view returns (uint256);
11 }
12 
13 contract NFTAllowlist is ERC721 {
14     using Counters for Counters.Counter;
15     
16     Counters.Counter private _tokenIds;
17 
18     // Deployed address of original collection
19     address public ogContractAddress;
20     OGCollectionInterface ogContract;
21     
22     constructor(address _ogContractAddress) ERC721("NFT Allowlist Demo", "NAD") {
23         ogContractAddress = _ogContractAddress;
24         ogContract = OGCollectionInterface(ogContractAddress);
25     }
26 
27     // Presale mint
28     function preSale() public {
29         require(ogContract.balanceOf(msg.sender) > 0, "Don't have NFT from original collection.");
30 
31         for (uint i = 0; i < 2; i++) {
32             _mintSingleNFT();
33         }
34 
35         console.log("2 NFTs minted using allowlist.");    
36     }
37     
38     function _mintSingleNFT() private {
39         uint newTokenID = _tokenIds.current();
40         _safeMint(msg.sender, newTokenID);
41         _tokenIds.increment();
42     }
43 }

Compile the contracts and make sure everything is working by running:

bash

$ npx hardhat compile

Step 5: Test the allowlist functionality locally

Next, write a script that allows us to test the allowlist locally. To do this, create a new file called run.jsin the scripts folder, then add the following code:

run.js

1 const hre = require("hardhat");
2 
3 async function main() {
4 
5     // Get wallet addresses from hardhat
6     const [owner, address1, address2] = await hre.ethers.getSigners();
7 
8     // Deploy OG collection and get deployed contract address
9     const ogFactory = await hre.ethers.getContractFactory("OGCollection");
10     const ogContract = await ogFactory.deploy();
11 
12     await ogContract.deployed();
13     console.log("OG Collection deployed to: ", ogContract.address, "\n");
14 
15     ogContractAddress = ogContract.address
16 
17     // Mint OG NFTs to address1
18     let txn;
19     txn = await ogContract.connect(address1).mintNft();
20     await txn.wait()
21     console.log("1 OG NFT minted to ", address1.address);
22 
23     // Deploy contract with allowlist 
24     const alFactory = await hre.ethers.getContractFactory("NftWithAllowlist");
25     const alContract = await alFactory.deploy(ogContractAddress);
26 
27     await alContract.deployed();
28     console.log("NFT with Allowlist deployed to: ", alContract.address, "\n");
29 
30     // Mint NFTs from address1 (has OG NFT)
31     console.log("Minting NFTs from address with OG NFT...")
32     txn = await alContract.connect(address1).preSale();
33     await txn.wait();
34 
35     // Mint NFTs from address2 (does not have OG NFT)
36     console.log("\nMinting NFTs from address without OG NFT...")
37     txn = await alContract.connect(address2).preSale();
38     await txn.wait();
39 }
40 
41 main()
42     .then(() => process.exit(0))
43     .catch((error) => {
44         console.error(error);
45         process.exit(1);
46     });

Run this script by running the following command in your terminal:

bash

$ npx hardhat run scripts/run.js

You should see output that looks like this:

bash

$ OG Collection deployed to:  0x5FbDB2315678afecb367f032d93F642f64180aa3 
> 
> 1 OG NFT minted to  0x70997970C51812dc3A010C7d01b50e0d17dc79C8
> NFT with Allowlist deployed to:  0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512 
> 
> Minting NFTs from address with OG NFT...
> 2 NFTs minted using allowlist.
> 
> Minting NFTs from address without OG NFT...
> Error: VM Exception while processing transaction: reverted with reason string 'Don't have NFT from original collection.'
>     at NftWithAllowlist.preSale (contracts/NftWithAllowlist.sol:29)
>     at HardhatNode._mineBlockWithPendingTxs (/Users/rounakbanik/alchemy-tut/nft-allowlist-2/node_modules/hardhat/src/internal/hardhat-network/provider/node.ts:1773:23)
>     at HardhatNode.mineBlock (/Users/rounakbanik/alchemy-tut/nft-allowlist-2/node_modules/hardhat/src/internal/hardhat-network/provider/node.ts:466:16)
>     at EthModule._sendTransactionAndReturnHash (/Users/rounakbanik/alchemy-tut/nft-allowlist-2/node_modules/hardhat/src/internal/hardhat-network/provider/modules/eth.ts:1504:18)
>     at HardhatNetworkProvider.request (/Users/rounakbanik/alchemy-tut/nft-allowlist-2/node_modules/hardhat/src/internal/hardhat-network/provider/provider.ts:118:18)
>     at EthersProviderWrapper.send (/Users/rounakbanik/alchemy-tut/nft-allowlist-2/node_modules/@nomiclabs/hardhat-ethers/src/internal/ethers-provider-wrapper.ts:13:20)

Above, you can see that an address with the OG NFT was able to mint but an address without the OG NFT was not.

Conclusion

Congratulations! You now know how to implement an on-chain NFT allowlist based on previously owned NFTs.

If you enjoyed this tutorial about creating on-chain allowlists, tweet us at @Alchemy and give us a shoutout!

Don’t forget to join our Discord server to meet other blockchain devs, builders, and entrepreneurs!

Ready to start building your NFT collection?

Create a free Alchemy account and do share your project with us!